home *** CD-ROM | disk | FTP | other *** search
/ AMIGA-CD 2 / Amiga-CD - Volume 2.iso / ungepackte_daten / 1994 / 8 / 05 / term-4.0-source.lha / termARexxCommands.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-07  |  98.0 KB  |  5,823 lines
  1. /*
  2. **    termARexxCommands.c
  3. **
  4. **    ARexx interface command support routines
  5. **
  6. **    Copyright © 1990-1994 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termARexxGlobal.h"
  11. #include "termEmulationProcess.h"
  12.  
  13.     /* Number of bytes already processed by ScanNodeFilter(). */
  14.  
  15. STATIC LONG WaitCount = 0;
  16.  
  17.     /* Cheapo shortcuts ;-) */
  18.  
  19. #define Args    Pkt -> Array
  20. #define Results    Pkt -> Results
  21.  
  22.     /* ScanNodeFilter():
  23.      *
  24.      *    Scan memory for a certain sequence.
  25.      */
  26.  
  27. STATIC STRPTR __regargs
  28. ScanNodeFilter(register STRPTR Data,register LONG Size,register struct WaitNode *Node,LONG *Position)
  29. {
  30.     register UBYTE c,Mask;
  31.  
  32.     *Position = 0;
  33.  
  34.     if(Config -> SerialConfig -> StripBit8)
  35.         Mask = 0x7F;
  36.     else
  37.         Mask = 0xFF;
  38.  
  39.     if(Node)
  40.     {
  41.         do
  42.         {
  43.             (*Position)++;
  44.  
  45.             if(c = ToUpper((*Data++) & Mask))
  46.             {
  47.                 register BYTE MatchMade;
  48.  
  49.                 do
  50.                 {
  51.                     MatchMade = FALSE;
  52.  
  53.                     if(Node -> Count == WaitCount)
  54.                     {
  55.                         if(c == Node -> Node . ln_Name[WaitCount] & Mask)
  56.                         {
  57.                             MatchMade = TRUE;
  58.  
  59.                             if(!Node -> Node . ln_Name[++Node -> Count])
  60.                             {
  61.                                 if(Node -> ResponseLen)
  62.                                 {
  63.                                     SerWriteVerbatim(Node -> Response,Node -> ResponseLen,FALSE);
  64.  
  65.                                     Node -> Count = 0;
  66.                                 }
  67.                                 else
  68.                                     return(Node -> Node . ln_Name);
  69.                             }
  70.                         }
  71.                     }
  72.  
  73.                     if(MatchMade)
  74.                         WaitCount++;
  75.                     else
  76.                     {
  77.                         if(WaitCount)
  78.                         {
  79.                             WaitCount = 0;
  80.  
  81.                             Node -> Count = 0;
  82.                         }
  83.                         else
  84.                             break;
  85.                     }
  86.                 }
  87.                 while(!WaitCount);
  88.             }
  89.         }
  90.         while(--Size);
  91.     }
  92.     else
  93.     {
  94.         do
  95.         {
  96.             (*Position)++;
  97.  
  98.             if(c = ToUpper((*Data++) & Mask))
  99.             {
  100.                 register BYTE MatchMade;
  101.  
  102.                 do
  103.                 {
  104.                     MatchMade = FALSE;
  105.  
  106.                     Node = (struct WaitNode *)GenericListTable[GLIST_WAIT] -> ListHeader . mlh_Head;
  107.  
  108.                     while(Node -> Node . ln_Succ)
  109.                     {
  110.                         if(Node -> Count == WaitCount)
  111.                         {
  112.                             if(c == Node -> Node . ln_Name[WaitCount] & Mask)
  113.                             {
  114.                                 Node -> Count++;
  115.  
  116.                                 MatchMade = TRUE;
  117.  
  118.                                 if(!Node -> Node . ln_Name[Node -> Count])
  119.                                 {
  120.                                     if(Node -> ResponseLen)
  121.                                     {
  122.                                         SerWriteVerbatim(Node -> Response,Node -> ResponseLen,FALSE);
  123.  
  124.                                         Node -> Count = 0;
  125.                                     }
  126.                                     else
  127.                                         return(Node -> Node . ln_Name);
  128.                                 }
  129.                             }
  130.                         }
  131.  
  132.                         Node = (struct WaitNode *)Node -> Node . ln_Succ;
  133.                     }
  134.  
  135.                     if(MatchMade)
  136.                         WaitCount++;
  137.                     else
  138.                     {
  139.                         if(WaitCount)
  140.                         {
  141.                             WaitCount = 0;
  142.  
  143.                             Node = (struct WaitNode *)GenericListTable[GLIST_WAIT] -> ListHeader . mlh_Head;
  144.  
  145.                             while(Node -> Node . ln_Succ)
  146.                             {
  147.                                 Node -> Count = 0;
  148.  
  149.                                 Node = (struct WaitNode *)Node -> Node . ln_Succ;
  150.                             }
  151.                         }
  152.                         else
  153.                             break;
  154.                     }
  155.                 }
  156.                 while(!WaitCount);
  157.             }
  158.         }
  159.         while(--Size);
  160.     }
  161.  
  162.     return(NULL);
  163. }
  164.  
  165. STRPTR
  166. RexxActivate(struct RexxPkt *Pkt)
  167. {
  168.     if(Window)
  169.         BumpWindow(Window);
  170.     else
  171.         Signal(ThisProcess,SIGBREAKF_CTRL_F);
  172.  
  173.     return(NULL);
  174. }
  175.  
  176. STRPTR
  177. RexxAdd(struct RexxPkt *Pkt)
  178. {
  179.     enum    {    ARG_ADD_FROM,ARG_ADD_BEFORE,ARG_ADD_AFTER,ARG_ADD_PHONEENTRY,
  180.             ARG_ADD_NAME,ARG_ADD_RESPONSE,ARG_ADD_COMMAND };
  181.  
  182.     WORD ListIndex;
  183.  
  184.     if((ListIndex = ToList(Args[ARG_ADD_FROM])) != -1)
  185.     {
  186.         struct GenericList    *List = GenericListTable[ListIndex];
  187.         BYTE             AddMode;
  188.  
  189.         if(Args[ARG_ADD_BEFORE])
  190.             AddMode = ADD_GLIST_BEFORE;
  191.         else
  192.         {
  193.             if(Args[ARG_ADD_AFTER])
  194.                 AddMode = ADD_GLIST_BEHIND;
  195.             else
  196.                 AddMode = ADD_GLIST_BOTTOM;
  197.         }
  198.  
  199.         if(ListIndex == GLIST_DIAL)
  200.         {
  201.             if(Args[ARG_ADD_PHONEENTRY])
  202.             {
  203.                 if(!IsNumeric(Args[ARG_ADD_PHONEENTRY]))
  204.                 {
  205.                     STRPTR Buffer;
  206.  
  207.                     if(Buffer = CreateMatchBuffer(Args[ARG_ADD_PHONEENTRY]))
  208.                     {
  209.                         struct DialNode    *Node;
  210.                         LONG         i;
  211.  
  212.                         for(i = 0 ; i < NumPhoneEntries ; i++)
  213.                         {
  214.                             if(MatchBuffer(Buffer,Phonebook[i] -> Header -> Name))
  215.                             {
  216.                                 if(Node = (struct DialNode *)CreateGenericListNode(sizeof(struct DialNode),NULL))
  217.                                 {
  218.                                     Node -> Entry = Phonebook[i];
  219.  
  220.                                     AddGenericListNode(List,(struct Node *)Node,AddMode);
  221.                                 }
  222.                                 else
  223.                                 {
  224.                                     Results[0] = RC_ERROR;
  225.                                     Results[1] = ERROR_NO_FREE_STORE;
  226.  
  227.                                     break;
  228.                                 }
  229.                             }
  230.                         }
  231.  
  232.                         DeleteMatchBuffer(Buffer);
  233.                     }
  234.                     else
  235.                     {
  236.                         Results[0] = RC_ERROR;
  237.                         Results[1] = ERROR_NO_FREE_STORE;
  238.                     }
  239.                 }
  240.                 else
  241.                 {
  242.                     LONG Index = Atol(Args[ARG_ADD_PHONEENTRY]);
  243.  
  244.                     if(Index < 0 || Index > NumPhoneEntries)
  245.                     {
  246.                         Results[0] = RC_ERROR;
  247.                         Results[1] = TERMERROR_INDEX_OUT_OF_RANGE;
  248.                     }
  249.                     else
  250.                     {
  251.                         struct DialNode    *Node;
  252.  
  253.                         if(Node = (struct DialNode *)CreateGenericListNode(sizeof(struct DialNode),NULL))
  254.                         {
  255.                             Node -> Entry = Phonebook[Index];
  256.  
  257.                             AddGenericListNode(List,(struct Node *)Node,AddMode);
  258.                         }
  259.                         else
  260.                         {
  261.                             Results[0] = RC_ERROR;
  262.                             Results[1] = ERROR_NO_FREE_STORE;
  263.                         }
  264.                     }
  265.                 }
  266.             }
  267.             else
  268.             {
  269.                 if(Args[ARG_ADD_NAME])
  270.                 {
  271.                     struct Node *Node;
  272.  
  273.                     if(Node = CreateGenericListNode(sizeof(struct DialNode),Args[ARG_ADD_NAME]))
  274.                         AddGenericListNode(List,Node,AddMode);
  275.                     else
  276.                     {
  277.                         Results[0] = RC_ERROR;
  278.                         Results[1] = ERROR_NO_FREE_STORE;
  279.                     }
  280.                 }
  281.             }
  282.         }
  283.         else
  284.         {
  285.             if(ListIndex == GLIST_WAIT)
  286.             {
  287.                 STRPTR    Response;
  288.                 LONG    ResponseLen;
  289.  
  290.                 if(Args[ARG_ADD_RESPONSE])
  291.                 {
  292.                     Response    = Args[ARG_ADD_RESPONSE];
  293.                     ResponseLen    = strlen(Response);
  294.                 }
  295.                 else
  296.                 {
  297.                     Response    = NULL;
  298.                     ResponseLen    = 0;
  299.                 }
  300.  
  301.                 if(Args[ARG_ADD_NAME])
  302.                 {
  303.                     struct WaitNode *Node;
  304.     
  305.                     if(Node = (struct WaitNode *)CreateGenericListNode(sizeof(struct WaitNode) + ResponseLen + 1,Args[ARG_ADD_NAME]))
  306.                     {
  307.                         WORD i,Len;
  308.     
  309.                         Len = TranslateString(Node -> Node . ln_Name,Node -> Node . ln_Name);
  310.     
  311.                         Node -> Node . ln_Name[Len] = 0;
  312.     
  313.                         for(i = 0 ; i < strlen(Node -> Node . ln_Name) ; i++)
  314.                             Node -> Node . ln_Name[i] = ToUpper(Node -> Node . ln_Name[i]);
  315.  
  316.                         if(Response && ResponseLen)
  317.                         {
  318.                             Node -> Response = &Node -> Node . ln_Name[Len + 1];
  319.  
  320.                             strcpy(Node -> Response,Response);
  321.  
  322.                             Node -> ResponseLen = TranslateString(Node -> Response,Node -> Response);
  323.                         }
  324.                         else
  325.                             Node -> ResponseLen = 0;
  326.     
  327.                         AddGenericListNode(List,Node,AddMode);
  328.                     }
  329.                     else
  330.                     {
  331.                         Results[0] = RC_ERROR;
  332.                         Results[1] = ERROR_NO_FREE_STORE;
  333.                     }
  334.                 }
  335.                 else
  336.                 {
  337.                     Results[0] = RC_ERROR;
  338.                     Results[1] = TERMERROR_WRONG_LIST;
  339.                 }
  340.             }
  341.             else
  342.             {
  343.                 if(ListIndex == GLIST_TRAP)
  344.                 {
  345.                     if(!Args[ARG_ADD_NAME] || !Args[ARG_ADD_COMMAND])
  346.                     {
  347.                         struct TrapNode    *Node;
  348.                         UBYTE         LocalBuffer[256];
  349.                         LONG         NameLen;
  350.  
  351.                         if(strlen(Args[ARG_ADD_NAME]) > 255)
  352.                             Args[ARG_ADD_NAME][255] = 0;
  353.  
  354.                         NameLen = TranslateString(Args[ARG_ADD_NAME],LocalBuffer);
  355.  
  356.                         if(Node = (struct TrapNode *)AllocVecPooled(sizeof(struct TrapNode) + strlen(Args[ARG_ADD_NAME]) + 1 + NameLen + strlen(Args[ARG_ADD_COMMAND]) + 1,MEMF_ANY))
  357.                         {
  358.                             STRPTR String = Node -> Node . ln_Name = (STRPTR)(Node + 1);
  359.  
  360.                             strcpy(String,Args[ARG_ADD_NAME]);
  361.  
  362.                             String += strlen(String) + 1;
  363.  
  364.                             Node -> Sequence = String;
  365.  
  366.                             CopyMem(LocalBuffer,String,NameLen);
  367.  
  368.                             String += NameLen;
  369.  
  370.                             Node -> Command = String;
  371.  
  372.                             strcpy(String,Args[ARG_ADD_COMMAND]);
  373.  
  374.                             Node -> SequenceLen = NameLen;
  375.                             Node -> Count = 0;
  376.  
  377.                             AddGenericListNode(List,Node,AddMode);
  378.                         }
  379.                         else
  380.                         {
  381.                             Results[0] = RC_ERROR;
  382.                             Results[1] = ERROR_NO_FREE_STORE;
  383.                         }
  384.                     }
  385.                     else
  386.                     {
  387.                         Results[0] = RC_ERROR;
  388.                         Results[1] = ERROR_REQUIRED_ARG_MISSING;
  389.                     }
  390.                 }
  391.                 else
  392.                 {
  393.                     if(Args[ARG_ADD_NAME])
  394.                     {
  395.                         struct Node *Node;
  396.         
  397.                         if(Node = CreateGenericListNode(sizeof(struct DialNode),Args[ARG_ADD_NAME]))
  398.                             AddGenericListNode(List,Node,AddMode);
  399.                         else
  400.                         {
  401.                             Results[0] = RC_ERROR;
  402.                             Results[1] = ERROR_NO_FREE_STORE;
  403.                         }
  404.                     }
  405.                     else
  406.                     {
  407.                         Results[0] = RC_ERROR;
  408.                         Results[1] = TERMERROR_WRONG_LIST;
  409.                     }
  410.                 }
  411.             }
  412.         }
  413.     }
  414.     else
  415.     {
  416.         Results[0] = RC_ERROR;
  417.         Results[1] = TERMERROR_UNKNOWN_LIST;
  418.     }
  419.  
  420.     return(NULL);
  421. }
  422.  
  423. STRPTR
  424. RexxBaud(struct RexxPkt *Pkt)
  425. {
  426.     enum    {    ARG_BAUD_RATE };
  427.  
  428.     LONG Rate = *(LONG *)Args[ARG_BAUD_RATE],Min = MILLION,Diff,Index;
  429.     WORD i;
  430.  
  431.     for(i = 0 ; i < NumBaudRates ; i++)
  432.     {
  433.         Diff = Rate - BaudRates[i];
  434.  
  435.         if(Diff >= 0 && Diff < Min)
  436.         {
  437.             Min    = Diff;
  438.             Index    = i;
  439.         }
  440.     }
  441.  
  442.     if(BaudRates[Index] != Config -> SerialConfig -> BaudRate)
  443.     {
  444.         Config -> SerialConfig -> BaudRate = BaudRates[Index];
  445.  
  446.         ConfigChanged = TRUE;
  447.  
  448.         UpdateRequired = TRUE;
  449.     }
  450.  
  451.     return(NULL);
  452. }
  453.  
  454. STRPTR
  455. RexxBeepScreen(struct RexxPkt *Pkt)
  456. {
  457.     BellSignal();
  458.  
  459.     return(NULL);
  460. }
  461.  
  462. STRPTR
  463. RexxCallMenu(struct RexxPkt *Pkt)
  464. {
  465.     enum    {    ARG_CALLMENU_TITLE };
  466.  
  467.     STRPTR Buffer;
  468.  
  469.     if(Buffer = CreateMatchBuffer(Args[ARG_CALLMENU_TITLE]))
  470.     {
  471.         WORD i;
  472.  
  473.         Results[0] = RC_WARN;
  474.  
  475.             /* Scan the menu list... */
  476.  
  477.         for(i = 0 ; TermMenu[i] . nm_Type != NM_END ; i++)
  478.         {
  479.                 /* Did we get a valid name string? */
  480.  
  481.             if(TermMenu[i] . nm_Label != NM_BARLABEL)
  482.             {
  483.                     /* Does the name match our template? */
  484.  
  485.                 if(MatchBuffer(Buffer,TermMenu[i] . nm_Label))
  486.                 {
  487.                     HandleMenuCode((ULONG)TermMenu[i] . nm_UserData,NULL);
  488.  
  489.                     Results[0] = RC_OK;
  490.  
  491.                     break;
  492.                 }
  493.             }
  494.         }
  495.  
  496.         DeleteMatchBuffer(Buffer);
  497.     }
  498.     else
  499.     {
  500.         Results[0] = RC_ERROR;
  501.         Results[1] = ERROR_NO_FREE_STORE;
  502.     }
  503.  
  504.     return(NULL);
  505. }
  506.  
  507. STRPTR
  508. RexxCapture(struct RexxPkt *Pkt)
  509. {
  510.     enum    {    ARG_CAPTURE_TO,ARG_CAPTURE_NAME };
  511.  
  512.     if(!Stricmp(Args[ARG_CAPTURE_TO],"PRINTER"))
  513.     {
  514.         if(!PrinterCapture)
  515.             OpenPrinterCapture(FALSE);
  516.     }
  517.     else
  518.     {
  519.         if(!Stricmp(Args[ARG_CAPTURE_TO],"FILE"))
  520.         {
  521.             if(FileCapture)
  522.             {
  523.                 Results[0] = RC_ERROR;
  524.                 Results[1] = ERROR_OBJECT_IN_USE;
  525.             }
  526.             else
  527.             {
  528.                 if(Args[ARG_CAPTURE_NAME])
  529.                 {
  530.                     if(FileCapture = BufferOpen(Args[ARG_CAPTURE_NAME],"a"))
  531.                         strcpy(CaptureName,Args[ARG_CAPTURE_NAME]);
  532.                     else
  533.                     {
  534.                         Results[0] = RC_ERROR;
  535.                         Results[1] = IoErr();
  536.                     }
  537.                 }
  538.                 else
  539.                 {
  540.                     UBYTE             DummyBuffer[MAX_FILENAME_LENGTH],
  541.                                 *DummyChar;
  542.                     struct FileRequester    *FileRequest;
  543.  
  544.                     if(!CaptureName[0])
  545.                     {
  546.                         strcpy(CaptureName,Config -> CaptureConfig -> CapturePath);
  547.  
  548.                         if(!AddPart(CaptureName,LocaleString(MSG_DIALPANEL_CAPTURE_NAME_TXT),MAX_FILENAME_LENGTH))
  549.                             CaptureName[0] = 0;
  550.                     }
  551.  
  552.                     strcpy(DummyBuffer,CaptureName);
  553.  
  554.                     DummyChar = PathPart(DummyBuffer);
  555.  
  556.                     *DummyChar = 0;
  557.  
  558.                     BlockWindows();
  559.  
  560.                     if(FileRequest = GetFile(Window,LocaleString(MSG_TERMMAIN_CAPTURE_TO_DISK_TXT),DummyBuffer,FilePart(CaptureName),DummyBuffer,NULL,TRUE,FALSE,FALSE,LocaleString(MSG_GLOBAL_OPEN_TXT),FALSE))
  561.                     {
  562.                         BYTE Continue;
  563.  
  564.                         if(GetFileSize(DummyBuffer))
  565.                         {
  566.                             Continue = TRUE;
  567.  
  568.                             switch(MyEasyRequest(Window,LocaleString(MSG_GLOBAL_FILE_ALREADY_EXISTS_TXT),LocaleString(MSG_GLOBAL_CREATE_APPEND_CANCEL_TXT),DummyBuffer))
  569.                             {
  570.                                 case 1:
  571.  
  572.                                     FileCapture = BufferOpen(DummyBuffer,"w");
  573.                                     break;
  574.  
  575.                                 case 2:
  576.  
  577.                                     FileCapture = BufferOpen(DummyBuffer,"a");
  578.                                     break;
  579.  
  580.                                 case 0:
  581.  
  582.                                     Results[0] = RC_WARN;
  583.                                     Continue = FALSE;
  584.                                     break;
  585.                             }
  586.                         }
  587.                         else
  588.                         {
  589.                             Continue = TRUE;
  590.  
  591.                             FileCapture = BufferOpen(DummyBuffer,"w");
  592.                         }
  593.  
  594.                         if(Continue)
  595.                         {
  596.                             if(!FileCapture)
  597.                             {
  598.                                 MyEasyRequest(Window,LocaleString(MSG_GLOBAL_ERROR_OPENING_FILE_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT),DummyBuffer);
  599.  
  600.                                 Results[0] = RC_ERROR;
  601.                                 Results[1] = IoErr();
  602.                             }
  603.                             else
  604.                             {
  605.                                 strcpy(CaptureName,DummyBuffer);
  606.  
  607.                                 CheckItem(MEN_CAPTURE_TO_FILE,TRUE);
  608.                             }
  609.                         }
  610.  
  611.                         FreeAslRequest(FileRequest);
  612.                     }
  613.  
  614.                     ReleaseWindows();
  615.                 }
  616.             }
  617.         }
  618.         else
  619.         {
  620.             Results[0] = RC_ERROR;
  621.             Results[1] = ERROR_REQUIRED_ARG_MISSING;
  622.         }
  623.     }
  624.  
  625.     ConOutputUpdate();
  626.  
  627.     return(NULL);
  628. }
  629.  
  630. STRPTR
  631. RexxClear(struct RexxPkt *Pkt)
  632. {
  633.     enum    {    ARG_CLEAR_FROM,ARG_CLEAR_FORCE };
  634.  
  635.     if(!Stricmp(Args[ARG_CLEAR_FROM],"BUFFER"))
  636.     {
  637.         if(Lines)
  638.         {
  639.             if(Args[ARG_CLEAR_FORCE])
  640.             {
  641.                 FreeBuffer();
  642.  
  643.                 TerminateBuffer();
  644.             }
  645.             else
  646.             {
  647.                 BlockWindows();
  648.  
  649.                 if(MyEasyRequest(Window,LocaleString(MSG_TERMMAIN_BUFFER_STILL_HOLDS_LINES_TXT),LocaleString(MSG_GLOBAL_YES_NO_TXT),Lines))
  650.                 {
  651.                     FreeBuffer();
  652.  
  653.                     TerminateBuffer();
  654.                 }
  655.                 else
  656.                     Results[0] = RC_WARN;
  657.  
  658.                 ReleaseWindows();
  659.             }
  660.         }
  661.     }
  662.     else
  663.     {
  664.         WORD ListIndex;
  665.  
  666.         if((ListIndex = ToList(Args[ARG_CLEAR_FROM])) != -1)
  667.             ClearGenericList(GenericListTable[ListIndex]);
  668.         else
  669.         {
  670.             Results[0] = RC_ERROR;
  671.             Results[1] = TERMERROR_UNKNOWN_LIST;
  672.         }
  673.     }
  674.  
  675.     return(NULL);
  676. }
  677.  
  678. STRPTR
  679. RexxClearScreen(struct RexxPkt *Pkt)
  680. {
  681.     if(XEmulatorBase && Config -> TerminalConfig -> EmulationMode == EMULATION_EXTERNAL)
  682.         XEmulatorClearConsole(XEM_IO);
  683.     else
  684.     {
  685.         DropMarker();
  686.  
  687.         ConBypass("\033[2J\033[H",-1);
  688.     }
  689.  
  690.     return(NULL);
  691. }
  692.  
  693. STRPTR
  694. RexxClose(struct RexxPkt *Pkt)
  695. {
  696.     enum    {    ARG_CLOSE_FROM };
  697.  
  698.     STATIC STRPTR ValidArgs[3] =
  699.     {
  700.         "PRINTER",
  701.         "FILE",
  702.         "ALL"
  703.     };
  704.  
  705.     WORD i;
  706.  
  707.     for(i = 0 ; i < 3 ; i++)
  708.     {
  709.         if(!Stricmp(Args[ARG_CLOSE_FROM],ValidArgs[i]))
  710.         {
  711.             if(i == 0 || i == 2)
  712.             {
  713.                 if(PrinterCapture)
  714.                     ClosePrinterCapture(TRUE);
  715.             }
  716.  
  717.             if(i == 1 || i == 2)
  718.             {
  719.                 if(FileCapture)
  720.                 {
  721.                     BufferClose(FileCapture);
  722.  
  723.                     CheckItem(MEN_CAPTURE_TO_FILE,FALSE);
  724.  
  725.                     FileCapture = NULL;
  726.  
  727.                     if(!GetFileSize(CaptureName))
  728.                         DeleteFile(CaptureName);
  729.                     else
  730.                     {
  731.                         AddProtection(CaptureName,FIBF_EXECUTE);
  732.  
  733.                         if(Config -> MiscConfig -> CreateIcons)
  734.                             AddIcon(CaptureName,FILETYPE_TEXT,TRUE);
  735.                     }
  736.  
  737.                     ConOutputUpdate();
  738.                 }
  739.             }
  740.  
  741.             return(NULL);
  742.         }
  743.     }
  744.  
  745.     Results[0] = RC_ERROR;
  746.     Results[1] = ERROR_TOO_MANY_ARGS;
  747.  
  748.     return(NULL);
  749. }
  750.  
  751. STRPTR
  752. RexxCloseDevice(struct RexxPkt *Pkt)
  753. {
  754.     ClearSerial();
  755.  
  756.     DeleteSerial();
  757.  
  758.     return(NULL);
  759. }
  760.  
  761. STRPTR
  762. RexxCloseRequester(struct RexxPkt *Pkt)
  763. {
  764.     if(ThisProcess)
  765.         Signal(ThisProcess,SIG_BREAK);
  766.     else
  767.         Results[0] = RC_WARN;
  768.  
  769.     return(NULL);
  770. }
  771.  
  772. STRPTR
  773. RexxDeactivate(struct RexxPkt *Pkt)
  774. {
  775.     Forbid();
  776.  
  777.     if(Window)
  778.         DoIconify = TRUE;
  779.  
  780.     Permit();
  781.  
  782.     return(NULL);
  783. }
  784.  
  785. STRPTR
  786. RexxDial(struct RexxPkt *Pkt)
  787. {
  788.     enum    {    ARG_SYNC,ARG_DIAL_NUM };
  789.  
  790.     struct PhoneNode    *DialNode;
  791.     struct GenericList    *List;
  792.  
  793.     if(Args[ARG_DIAL_NUM])
  794.     {
  795.         struct List *LocalList;
  796.  
  797.         if(LocalList = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY))
  798.         {
  799.             LONG Len = strlen(Args[ARG_DIAL_NUM]);
  800.  
  801.             NewList(LocalList);
  802.  
  803.             if(DialNode = (struct PhoneNode *)AllocVecPooled(sizeof(struct PhoneNode) + Len + 1,MEMF_ANY | MEMF_CLEAR))
  804.             {
  805.                 DialNode -> VanillaNode . ln_Name = (STRPTR)(DialNode + 1);
  806.  
  807.                 strcpy(DialNode -> VanillaNode . ln_Name,Args[ARG_DIAL_NUM]);
  808.  
  809.                 AddTail(LocalList,&DialNode -> VanillaNode);
  810.  
  811.                 FreeDialList(TRUE);
  812.  
  813.                 DialList = LocalList;
  814.             }
  815.             else
  816.             {
  817.                 FreeVecPooled(LocalList);
  818.  
  819.                 Results[0] = RC_ERROR;
  820.                 Results[1] = ERROR_NO_FREE_STORE;
  821.  
  822.                 return(NULL);
  823.             }
  824.         }
  825.     }
  826.     else
  827.     {
  828.         if(GenericListCount(List = GenericListTable[GLIST_DIAL]))
  829.         {
  830.             struct DialNode *Node = (struct DialNode *)FirstGenericListNode(List);
  831.  
  832.             if(Node)
  833.             {
  834.                 LONG Len;
  835.  
  836.                 if(!DialList)
  837.                 {
  838.                     if(DialList = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY | MEMF_CLEAR))
  839.                         NewList(DialList);
  840.                 }
  841.  
  842.                 if(DialList)
  843.                 {
  844.                     while(Node)
  845.                     {
  846.                         if(Node -> Entry)
  847.                             Len = 0;
  848.                         else
  849.                             Len = strlen(Node -> Node . ln_Name) + 1;
  850.  
  851.                         if(DialNode = (struct PhoneNode *)AllocVecPooled(sizeof(struct PhoneNode) + Len,MEMF_ANY | MEMF_CLEAR))
  852.                         {
  853.                             if(Node -> Entry)
  854.                                 DialNode -> Entry = Node -> Entry;
  855.                             else
  856.                             {
  857.                                 DialNode -> VanillaNode . ln_Name = (STRPTR)(DialNode + 1);
  858.  
  859.                                 strcpy(DialNode -> VanillaNode . ln_Name,Node -> Node . ln_Name);
  860.                             }
  861.  
  862.                             AddTail(DialList,&DialNode -> VanillaNode);
  863.                         }
  864.                         else
  865.                         {
  866.                             FreeDialList(FALSE);
  867.  
  868.                             Results[0] = RC_ERROR;
  869.                             Results[1] = ERROR_NO_FREE_STORE;
  870.  
  871.                             return(NULL);
  872.                         }
  873.  
  874.                         Node = (struct DialNode *)NextGenericListNode(List);
  875.                     }
  876.                 }
  877.             }
  878.         }
  879.     }
  880.  
  881.     if(DialList)
  882.     {
  883.         if(DialList -> lh_Head -> ln_Succ)
  884.         {
  885.             DoDial = DIAL_LIST;
  886.  
  887.             Forbid();
  888.  
  889.             if(!DialMsg && Args[ARG_SYNC])
  890.             {
  891.                 DialMsg = Pkt -> RexxMsg;
  892.  
  893.                 Pkt -> RexxMsg = NULL;
  894.             }
  895.  
  896.             Permit();
  897.         }
  898.         else
  899.         {
  900.             FreeDialList(FALSE);
  901.  
  902.             Results[0] = RC_ERROR;
  903.             Results[1] = TERMERROR_LIST_IS_ALREADY_EMPTY;
  904.         }
  905.     }
  906.     else
  907.     {
  908.         Results[0] = RC_ERROR;
  909.         Results[1] = ERROR_NO_FREE_STORE;
  910.     }
  911.  
  912.     return(NULL);
  913. }
  914.  
  915. STRPTR
  916. RexxDelay(struct RexxPkt *Pkt)
  917. {
  918.     enum    {    ARG_DELAY_MICROSECONDS,ARG_DELAY_SECONDS,ARG_DELAY_MINUTES,ARG_DELAY_QUIET };
  919.  
  920.     LONG    Seconds = 0,
  921.         Micros;
  922.     ULONG    Signals;
  923.     BYTE    Quiet;
  924.  
  925.     if(Args[ARG_DELAY_QUIET] || !ReadRequest || !WriteRequest)
  926.         Quiet = TRUE;
  927.     else
  928.         Quiet = FALSE;
  929.  
  930.     if(Args[ARG_DELAY_MINUTES])
  931.         Seconds += 60 * (*(LONG *)Args[ARG_DELAY_MINUTES]);
  932.  
  933.     if(Args[ARG_DELAY_SECONDS])
  934.         Seconds += *(LONG *)Args[ARG_DELAY_SECONDS];
  935.  
  936.     if(Args[ARG_DELAY_MICROSECONDS])
  937.         Micros = *(LONG *)Args[ARG_DELAY_MICROSECONDS];
  938.     else
  939.         Micros = 0;
  940.  
  941.     if(Seconds || Micros)
  942.     {
  943.         StartTime(Seconds,Micros);
  944.  
  945.         BlockWindows();
  946.  
  947.         if(Marking)
  948.             DropMarker();
  949.  
  950.         if(Quiet)
  951.             Signals = NULL;
  952.         else
  953.         {
  954.             if(DataHold)
  955.             {
  956.                 ConProcess(DataHold,DataSize);
  957.  
  958.                 Status = STATUS_READY;
  959.  
  960.                 DataHold = NULL;
  961.  
  962.                 RestartSerial(TRUE);
  963.             }
  964.  
  965.             Signals = CheckSignal(SIG_SERIAL);
  966.         }
  967.  
  968.         FOREVER
  969.         {
  970.             if(Signals & SIG_SERIAL)
  971.             {
  972.                 if(!WaitIO(ReadRequest))
  973.                 {
  974.                     LONG Length;
  975.  
  976.                     BytesIn++;
  977.  
  978.                     ConProcess(ReadBuffer,1);
  979.  
  980.                     Status = STATUS_READY;
  981.  
  982.                         /* Check how many bytes are still in
  983.                          * the serial buffer.
  984.                          */
  985.  
  986.                     WriteRequest -> IOSer . io_Command = SDCMD_QUERY;
  987.  
  988.                     DoIO(WriteRequest);
  989.  
  990.                     if(Length = WriteRequest -> IOSer . io_Actual)
  991.                     {
  992.                         if(Length > Config -> SerialConfig -> SerialBufferSize)
  993.                             Length = Config -> SerialConfig -> SerialBufferSize;
  994.  
  995.                         if(Length > Config -> SerialConfig -> Quantum)
  996.                             Length = Config -> SerialConfig -> Quantum;
  997.  
  998.                         ReadRequest -> IOSer . io_Command    = CMD_READ;
  999.                         ReadRequest -> IOSer . io_Data        = ReadBuffer;
  1000.                         ReadRequest -> IOSer . io_Length    = Length;
  1001.  
  1002.                         if(!DoIO(ReadRequest))
  1003.                         {
  1004.                             BytesIn += Length;
  1005.  
  1006.                                 /* Send the data to the console. */
  1007.  
  1008.                             ConProcess(ReadBuffer,Length);
  1009.  
  1010.                             Status = STATUS_READY;
  1011.                         }
  1012.                     }
  1013.                 }
  1014.  
  1015.                 RestartSerial(TRUE);
  1016.             }
  1017.  
  1018.             if(Signals & SIG_BREAK)
  1019.             {
  1020.                 StopTime();
  1021.  
  1022.                 Results[0] = RC_WARN;
  1023.  
  1024.                 break;
  1025.             }
  1026.  
  1027.             if(Signals & SIG_TIMER)
  1028.             {
  1029.                 WaitIO(TimeRequest);
  1030.  
  1031.                 break;
  1032.             }
  1033.  
  1034.             if(Quiet)
  1035.                 Signals = Wait(SIG_TIMER | SIG_BREAK);
  1036.             else
  1037.                 Signals = Wait(SIG_TIMER | SIG_BREAK | SIG_SERIAL);
  1038.         }
  1039.  
  1040.         ReleaseWindows();
  1041.     }
  1042.  
  1043.     return(NULL);
  1044. }
  1045.  
  1046. STRPTR
  1047. RexxDuplex(struct RexxPkt *Pkt)
  1048. {
  1049.     enum    {    ARG_DUPLEX_FULL,ARG_DUPLEX_HALF };
  1050.  
  1051.     BYTE Mode;
  1052.  
  1053.     if(Args[ARG_DUPLEX_FULL])
  1054.         Mode = DUPLEX_FULL;
  1055.  
  1056.     if(Args[ARG_DUPLEX_HALF])
  1057.         Mode = DUPLEX_HALF;
  1058.  
  1059.     if(Config -> SerialConfig -> Duplex != Mode)
  1060.     {
  1061.         Config -> SerialConfig -> Duplex = Mode;
  1062.  
  1063.         UpdateRequired = TRUE;
  1064.  
  1065.         ConfigChanged = TRUE;
  1066.     }
  1067.  
  1068.     return(NULL);
  1069. }
  1070.  
  1071. STRPTR
  1072. RexxFault(struct RexxPkt *Pkt)
  1073. {
  1074.     enum    {    ARG_FAULT_CODE };
  1075.  
  1076.     LONG    Code = *(LONG *)Args[ARG_FAULT_CODE];
  1077.     UBYTE    RexxResultString[256];
  1078.     STRPTR    Result;
  1079.  
  1080.     if(Code >= ERR10_001 && Code <= ERR10_048)
  1081.         Result = LocaleString(MSG_AREXX_SYSERR10_001_TXT + Code - ERR10_001);
  1082.     else
  1083.     {
  1084.         if(Code >= TERMERROR_NO_DATA_TO_PROCESS && Code <= TERMERROR_WRONG_LIST)
  1085.             Result = LocaleString(MSG_AREXX_HOSTERR_000_TXT + Code - TERMERROR_NO_DATA_TO_PROCESS);
  1086.         else
  1087.         {
  1088.             Fault(Code,"",RexxResultString,256);
  1089.  
  1090.             Result = &RexxResultString[2];
  1091.         }
  1092.     }
  1093.  
  1094.     return(CreateResult(Result,Results));
  1095. }
  1096.  
  1097. STRPTR
  1098. RexxGetClip(struct RexxPkt *Pkt)
  1099. {
  1100.     enum    {    ARG_GETCLIP_UNIT };
  1101.  
  1102.     struct IFFHandle    *Handle;
  1103.     STRPTR             ResultBuffer = NULL;
  1104.  
  1105.     if(Handle = AllocIFF())
  1106.     {
  1107.         if(Args[ARG_GETCLIP_UNIT])
  1108.             Handle -> iff_Stream = (ULONG)OpenClipboard(*(LONG *)Args[ARG_GETCLIP_UNIT]);
  1109.         else
  1110.             Handle -> iff_Stream = (ULONG)OpenClipboard(Config -> ClipConfig -> ClipboardUnit);
  1111.  
  1112.         if(Handle -> iff_Stream)
  1113.         {
  1114.             InitIFFasClip(Handle);
  1115.  
  1116.             if(!OpenIFF(Handle,IFFF_READ))
  1117.             {
  1118.                 if(!StopChunk(Handle,ID_FTXT,ID_CHRS))
  1119.                 {
  1120.                     if(!ParseIFF(Handle,IFFPARSE_SCAN))
  1121.                     {
  1122.                         struct ContextNode *ContextNode;
  1123.  
  1124.                         ContextNode = CurrentChunk(Handle);
  1125.  
  1126.                         if(ContextNode -> cn_Type == ID_FTXT && ContextNode -> cn_Size > 0)
  1127.                         {
  1128.                             STRPTR Result;
  1129.  
  1130.                             if(Result = (STRPTR)AllocVecPooled(ContextNode -> cn_Size,MEMF_ANY))
  1131.                             {
  1132.                                 if(ReadChunkBytes(Handle,Result,ContextNode -> cn_Size) == ContextNode -> cn_Size)
  1133.                                     ResultBuffer = CreateArgstring(Result,ContextNode -> cn_Size);
  1134.  
  1135.                                 FreeVecPooled(Result);
  1136.                             }
  1137.                             else
  1138.                             {
  1139.                                 Results[0] = RC_ERROR;
  1140.                                 Results[1] = ERROR_NO_FREE_STORE;
  1141.                             }
  1142.                         }
  1143.                         else
  1144.                             Results[0] = RC_WARN;
  1145.                     }
  1146.                     else
  1147.                     {
  1148.                         Results[0] = RC_ERROR;
  1149.                         Results[1] = ERROR_OBJECT_NOT_FOUND;
  1150.                     }
  1151.                 }
  1152.                 else
  1153.                 {
  1154.                     Results[0] = RC_ERROR;
  1155.                     Results[1] = ERROR_OBJECT_NOT_FOUND;
  1156.                 }
  1157.  
  1158.                 CloseIFF(Handle);
  1159.             }
  1160.             else
  1161.             {
  1162.                 Results[0] = RC_ERROR;
  1163.                 Results[1] = ERROR_OBJECT_NOT_FOUND;
  1164.             }
  1165.  
  1166.             CloseClipboard((struct ClipboardHandle *)Handle -> iff_Stream);
  1167.         }
  1168.         else
  1169.         {
  1170.             Results[0] = RC_ERROR;
  1171.             Results[1] = TERMERROR_UNIT_NOT_AVAILABLE;
  1172.         }
  1173.  
  1174.         FreeIFF(Handle);
  1175.     }
  1176.     else
  1177.     {
  1178.         Results[0] = RC_ERROR;
  1179.         Results[1] = ERROR_OBJECT_NOT_FOUND;
  1180.     }
  1181.  
  1182.     return(ResultBuffer);
  1183. }
  1184.  
  1185. STRPTR
  1186. RexxGoOnline(struct RexxPkt *Pkt)
  1187. {
  1188.     if(!Online)
  1189.     {
  1190.         WasOnline = FALSE;
  1191.  
  1192.         Online = TRUE;
  1193.  
  1194.         BaudCount = 0;
  1195.         BaudBuffer[0] = 0;
  1196.         BaudPending = FALSE;
  1197.     }
  1198.  
  1199.     return(NULL);
  1200. }
  1201.  
  1202. STRPTR
  1203. RexxHangup(struct RexxPkt *Pkt)
  1204. {
  1205.     BYTE OldStatus = Status;
  1206.  
  1207.     if(!WriteRequest)
  1208.     {
  1209.         Results[0] = RC_WARN;
  1210.  
  1211.         return(NULL);
  1212.     }
  1213.  
  1214.     BlockWindows();
  1215.  
  1216.     HangUp();
  1217.     Status = STATUS_HANGUP;
  1218.  
  1219.         /* Are we to drop the DTR line
  1220.          * before sending the hangup
  1221.          * string?
  1222.          */
  1223.  
  1224.     if(Config -> ModemConfig -> DropDTR)
  1225.     {
  1226.             /* Let's be nice and try to transmit the
  1227.              * `drop the line' command before
  1228.              * trying to close and reopen the driver.
  1229.              */
  1230.  
  1231.         WriteRequest -> IOSer . io_Command    = SIOCMD_SETCTRLLINES;
  1232.         WriteRequest -> IOSer . io_Offset    = SIOB_DTRF;
  1233.         WriteRequest -> IOSer . io_Length    = 0;
  1234.  
  1235.             /* Transmit the command. */
  1236.  
  1237.         if(!DoIO(WriteRequest))
  1238.         {
  1239.                 /* Wait a bit... */
  1240.  
  1241.             WaitTime(1,0);
  1242.  
  1243.                 /* Raise the line again. */
  1244.  
  1245.             WriteRequest -> IOSer . io_Command    = SIOCMD_SETCTRLLINES;
  1246.             WriteRequest -> IOSer . io_Offset    = SIOB_DTRF;
  1247.             WriteRequest -> IOSer . io_Length    = SIOB_DTRF;
  1248.  
  1249.             DoIO(WriteRequest);
  1250.         }
  1251.         else
  1252.         {
  1253.                 /* Do it the standard way: close and reopen
  1254.                  * the serial driver (the serial.device is
  1255.                  * supposed to drop the DTR line when closed).
  1256.                  */
  1257.  
  1258.             if(!DropDTR())
  1259.             {
  1260.                 if(!MyEasyRequest(Window,LocaleString(MSG_TERMMAIN_FAILED_TO_REOPEN_UNIT_TXT),LocaleString(MSG_TERMMAIN_IGNORE_QUIT_TXT),Config -> SerialConfig -> SerialDevice,Config -> SerialConfig -> UnitNumber))
  1261.                     MainTerminated = TRUE;
  1262.             }
  1263.         }
  1264.     }
  1265.  
  1266.         /* Transmit the hangup command. */
  1267.  
  1268.     SerialCommand(Config -> ModemConfig -> ModemHangup);
  1269.  
  1270.         /* Reset to old status. */
  1271.  
  1272.     Status = OldStatus;
  1273.  
  1274.         /* We are no longer online. */
  1275.  
  1276.     Online = FALSE;
  1277.  
  1278.         /* Reset time limit. */
  1279.  
  1280.     LimitCount = -1;
  1281.  
  1282.         /* Clear the password. */
  1283.  
  1284.     Password[0]        = 0;
  1285.     UserName[0]        = 0;
  1286.  
  1287.     CurrentBBSName[0]    = 0;
  1288.     CurrentBBSComment[0]    = 0;
  1289.     CurrentBBSNumber[0]    = 0;
  1290.  
  1291.         /* Note the  last action. */
  1292.  
  1293.     LogAction(LocaleString(MSG_TERMMAIN_LOGMSG_HANG_UP_TXT));
  1294.  
  1295.     ReleaseWindows();
  1296.  
  1297.         /* Execute logoff macro. */
  1298.  
  1299.     if(WasOnline)
  1300.         SerialCommand(Config -> CommandConfig -> LogoffMacro);
  1301.  
  1302.         /* Update the logfile. */
  1303.  
  1304.     StopCall(FALSE);
  1305.  
  1306.         /* Don't execute the logoff macro twice. */
  1307.  
  1308.     WasOnline = FALSE;
  1309.  
  1310.         /* Enable the dialing functions. */
  1311.  
  1312.     SetDialMenu(TRUE);
  1313.  
  1314.     Status = OldStatus;
  1315.  
  1316.     if(Config -> ModemConfig -> RedialAfterHangup)
  1317.     {
  1318.         if(DialList)
  1319.         {
  1320.             if(DialList -> lh_Head -> ln_Succ)
  1321.                 DoDial = DIAL_REDIAL;
  1322.         }
  1323.     }
  1324.  
  1325.     ChosenEntry = NULL;
  1326.  
  1327.     return(NULL);
  1328. }
  1329.  
  1330. STRPTR
  1331. RexxHelp(struct RexxPkt *Pkt)
  1332. {
  1333.     enum    {    ARG_HELP_COMMAND,ARG_HELP_PROMPT };
  1334.  
  1335.     if(Args[ARG_HELP_PROMPT])
  1336.         GuideSetup();
  1337.     else
  1338.     {
  1339.         WORD i;
  1340.  
  1341.         for(i = 0 ; i < CommandTableSize ; i++)
  1342.         {
  1343.             if(!Stricmp(Args[ARG_HELP_COMMAND],CommandTable[i] . Name))
  1344.             {
  1345.                 if(CommandTable[i] . Arguments)
  1346.                     return(CreateResult(CommandTable[i] . Arguments,Results));
  1347.                 else
  1348.                     return(CreateResult(",",Results));
  1349.             }
  1350.         }
  1351.  
  1352.         Results[0] = RC_ERROR;
  1353.         Results[1] = ERROR_OBJECT_NOT_FOUND;
  1354.     }
  1355.  
  1356.     return(NULL);
  1357. }
  1358.  
  1359. STRPTR
  1360. RexxOpen(struct RexxPkt *Pkt)
  1361. {
  1362.     enum    {    ARG_OPEN_NAME,ARG_OPEN_TO };
  1363.  
  1364.     WORD Index = ToConfig(Args[ARG_OPEN_TO]);
  1365.  
  1366.     if(Index == -1 || Index > DATATYPE_PHONEBOOK)
  1367.     {
  1368.         Results[0] = RC_ERROR;
  1369.         Results[1] = ERROR_OBJECT_NOT_FOUND;
  1370.     }
  1371.     else
  1372.     {
  1373.         UBYTE    DummyBuffer[MAX_FILENAME_LENGTH];
  1374.         STRPTR    FileName;
  1375.  
  1376.         if(Args[ARG_OPEN_NAME])
  1377.             FileName = Args[ARG_OPEN_NAME];
  1378.         else
  1379.         {
  1380.             STRPTR             Title;
  1381.             struct FileRequester    *FileRequest;
  1382.  
  1383.             FileName = NULL;
  1384.  
  1385.             switch(Index)
  1386.             {
  1387.                 case DATATYPE_TRANSLATIONS:
  1388.  
  1389.                     Title = LocaleString(MSG_PHONEPANEL_SELECT_TRANSLATION_TXT);
  1390.                     break;
  1391.  
  1392.                 case DATATYPE_FUNCTIONKEYS:
  1393.  
  1394.                     Title = LocaleString(MSG_PHONEPANEL_SELECT_KEYBOARD_MACROS_TXT);
  1395.                     break;
  1396.  
  1397.                 case DATATYPE_CURSORKEYS:
  1398.  
  1399.                     Title = LocaleString(MSG_PHONEPANEL_SELECT_CURSOR_KEYS_TXT);
  1400.                     break;
  1401.  
  1402.                 case DATATYPE_FASTMACROS:
  1403.  
  1404.                     Title = LocaleString(MSG_PHONEPANEL_SELECT_FAST_MACROS_TXT);
  1405.                     break;
  1406.  
  1407.                 case DATATYPE_HOTKEYS:
  1408.  
  1409.                     Title = LocaleString(MSG_HOTKEYPANEL_LOAD_HOTKEYS_TXT);
  1410.                     break;
  1411.  
  1412.                 case DATATYPE_SPEECH:
  1413.  
  1414.                     Title = LocaleString(MSG_SPEECHPANEL_LOAD_SPEECH_SETTINGS_TXT);
  1415.                     break;
  1416.  
  1417.                 case DATATYPE_SOUND:
  1418.  
  1419.                     Title = LocaleString(MSG_SOUNDPANEL_LOAD_SOUNDS_TXT);
  1420.                     break;
  1421.  
  1422.                 case DATATYPE_BUFFER:
  1423.  
  1424.                     Title = LocaleString(MSG_TERMMAIN_LOAD_BUFFER_TXT);
  1425.                     break;
  1426.  
  1427.                 case DATATYPE_CONFIGURATION:
  1428.  
  1429.                     Title = LocaleString(MSG_TERMMAIN_OPEN_PREFERENCES_TXT);
  1430.                     break;
  1431.  
  1432.                 case DATATYPE_PHONEBOOK:
  1433.  
  1434.                     Title = LocaleString(MSG_PHONEPANEL_LOAD_PHONEBOOK_TXT);
  1435.                     break;
  1436.             }
  1437.  
  1438.             BlockWindows();
  1439.  
  1440.             if(FileRequest = GetFile(Window,Title,"","",DummyBuffer,NULL,FALSE,FALSE,FALSE,"Ok",TRUE))
  1441.             {
  1442.                 FileName = DummyBuffer;
  1443.  
  1444.                 FreeAslRequest(FileRequest);
  1445.             }
  1446.             else
  1447.                 Results[0] = RC_WARN;
  1448.  
  1449.             ReleaseWindows();
  1450.         }
  1451.  
  1452.         if(FileName)
  1453.         {
  1454.             if(!GetFileSize(FileName))
  1455.             {
  1456.                 Results[0] = RC_ERROR;
  1457.                 Results[1] = ERROR_OBJECT_NOT_FOUND;
  1458.  
  1459.                 return(NULL);
  1460.             }
  1461.  
  1462.             BlockWindows();
  1463.  
  1464.             switch(Index)
  1465.             {
  1466.                 case DATATYPE_TRANSLATIONS:
  1467.                 {
  1468.                     struct TranslationEntry    **Send,
  1469.                                 **Receive = NULL;
  1470.                     BYTE            Success = FALSE;
  1471.  
  1472.                     if(Send = AllocTranslationTable())
  1473.                     {
  1474.                         if(Receive = AllocTranslationTable())
  1475.                         {
  1476.                             if(!(Success = LoadTranslationTables(FileName,Send,Receive)))
  1477.                             {
  1478.                                 Results[0] = RC_ERROR;
  1479.                                 Results[1] = IoErr();
  1480.                             }
  1481.                         }
  1482.                         else
  1483.                         {
  1484.                             Results[0] = RC_ERROR;
  1485.                             Results[1] = ERROR_NO_FREE_STORE;
  1486.                         }
  1487.                     }
  1488.                     else
  1489.                     {
  1490.                         Results[0] = RC_ERROR;
  1491.                         Results[1] = ERROR_NO_FREE_STORE;
  1492.                     }
  1493.  
  1494.                     if(!Success)
  1495.                     {
  1496.                         if(Send)
  1497.                             FreeTranslationTable(Send);
  1498.  
  1499.                         if(Receive)
  1500.                             FreeTranslationTable(Receive);
  1501.                     }
  1502.                     else
  1503.                     {
  1504.                         strcpy(Config -> FileConfig -> TranslationFileName,FileName);
  1505.  
  1506.                         strcpy(LastTranslation,FileName);
  1507.  
  1508.                         FreeTranslationTable(SendTable);
  1509.                         FreeTranslationTable(ReceiveTable);
  1510.  
  1511.                         SendTable    = Send;
  1512.                         ReceiveTable    = Receive;
  1513.                     }
  1514.                 }
  1515.  
  1516.                 break;
  1517.  
  1518.                 case DATATYPE_FUNCTIONKEYS:
  1519.                 {
  1520.                     if(!LoadMacros(FileName,MacroKeys))
  1521.                     {
  1522.                         Results[0] = RC_ERROR;
  1523.                         Results[1] = IoErr();
  1524.                     }
  1525.                     else
  1526.                     {
  1527.                         MacroChanged = FALSE;
  1528.  
  1529.                         strcpy(Config -> FileConfig -> MacroFileName,FileName);
  1530.  
  1531.                         strcpy(LastMacros,FileName);
  1532.                     }
  1533.                 }
  1534.  
  1535.                 break;
  1536.  
  1537.                 case DATATYPE_CURSORKEYS:
  1538.                 {
  1539.                     if(!ReadIFFData(FileName,CursorKeys,sizeof(struct CursorKeys),ID_KEYS))
  1540.                     {
  1541.                         Results[0] = RC_ERROR;
  1542.                         Results[1] = IoErr();
  1543.                     }
  1544.                     else
  1545.                     {
  1546.                         CursorKeysChanged = FALSE;
  1547.  
  1548.                         strcpy(Config -> FileConfig -> CursorFileName,FileName);
  1549.  
  1550.                         strcpy(LastCursorKeys,FileName);
  1551.                     }
  1552.                 }
  1553.  
  1554.                 break;
  1555.  
  1556.                 case DATATYPE_FASTMACROS:
  1557.                 {
  1558.                     if(!LoadFastMacros(FileName))
  1559.                     {
  1560.                         Results[0] = RC_ERROR;
  1561.                         Results[1] = IoErr();
  1562.                     }
  1563.                     else
  1564.                     {
  1565.                         strcpy(Config -> FileConfig -> FastMacroFileName,FileName);
  1566.  
  1567.                         strcpy(LastFastMacros,FileName);
  1568.  
  1569.                         FastMacrosChanged = FALSE;
  1570.                     }
  1571.  
  1572.                     RefreshFastWindow(TRUE);
  1573.                 }
  1574.  
  1575.                 break;
  1576.  
  1577.                 case DATATYPE_HOTKEYS:
  1578.                 {
  1579.                     if(!LoadHotkeys(FileName,&Hotkeys))
  1580.                     {
  1581.                         Results[0] = RC_ERROR;
  1582.                         Results[1] = IoErr();
  1583.                     }
  1584.                     else
  1585.                     {
  1586.                         strcpy(LastKeys,FileName);
  1587.  
  1588.                         HotkeysChanged = FALSE;
  1589.  
  1590.                         SetupCx();
  1591.                     }
  1592.                 }
  1593.  
  1594.                 break;
  1595.  
  1596.                 case DATATYPE_SPEECH:
  1597.                 {
  1598.                     if(!ReadIFFData(FileName,&SpeechConfig,sizeof(struct SpeechConfig),ID_SPEK))
  1599.                     {
  1600.                         Results[0] = RC_ERROR;
  1601.                         Results[1] = IoErr();
  1602.                     }
  1603.                     else
  1604.                     {
  1605.                         strcpy(LastSpeech,FileName);
  1606.  
  1607.                         SpeechSetup();
  1608.  
  1609.                         SpeechChanged = FALSE;
  1610.                     }
  1611.                 }
  1612.  
  1613.                 break;
  1614.  
  1615.                 case DATATYPE_SOUND:
  1616.                 {
  1617.                     if(!ReadIFFData(FileName,&SoundConfig,sizeof(struct SoundConfig),ID_SOUN))
  1618.                     {
  1619.                         Results[0] = RC_ERROR;
  1620.                         Results[1] = IoErr();
  1621.                     }
  1622.                     else
  1623.                     {
  1624.                         strcpy(LastSound,FileName);
  1625.  
  1626.                         SoundInit();
  1627.  
  1628.                         SoundChanged = FALSE;
  1629.                     }
  1630.                 }
  1631.  
  1632.                 break;
  1633.  
  1634.                 case DATATYPE_BUFFER:
  1635.                 {
  1636.                     BPTR SomeFile;
  1637.  
  1638.                     if(SomeFile = Open(FileName,MODE_OLDFILE))
  1639.                     {
  1640.                         LONG Len;
  1641.  
  1642.                         LineRead(NULL,NULL,NULL);
  1643.  
  1644.                         while((Len = LineRead(SomeFile,FileName,80)) > 0)
  1645.                             StoreBuffer(FileName,Len);
  1646.  
  1647.                         Close(SomeFile);
  1648.  
  1649.                         BufferChanged = TRUE;
  1650.                     }
  1651.                     else
  1652.                     {
  1653.                         Results[0] = RC_ERROR;
  1654.                         Results[1] = IoErr();
  1655.                     }
  1656.                 }
  1657.  
  1658.                 break;
  1659.  
  1660.                 case DATATYPE_CONFIGURATION:
  1661.                 {
  1662.                     if(ReadConfig(FileName,PrivateConfig))
  1663.                     {
  1664.                         SwapConfig(PrivateConfig,Config);
  1665.  
  1666.                         strcpy(FileName,LastConfig);
  1667.  
  1668.                         ConfigSetup();
  1669.  
  1670.                         ConfigChanged = FALSE;
  1671.                     }
  1672.                     else
  1673.                     {
  1674.                         Results[0] = RC_ERROR;
  1675.                         Results[1] = IoErr();
  1676.                     }
  1677.                 }
  1678.  
  1679.                 break;
  1680.  
  1681.                 case DATATYPE_PHONEBOOK:
  1682.                 {
  1683.                     if(ChosenEntry)
  1684.                     {
  1685.                         Results[0] = RC_ERROR;
  1686.                         Results[1] = ERROR_OBJECT_IN_USE;
  1687.                     }
  1688.                     else
  1689.                     {
  1690.                         if(!LoadPhonebook(FileName))
  1691.                         {
  1692.                             Results[0] = RC_ERROR;
  1693.                             Results[1] = IoErr();
  1694.                         }
  1695.                         else
  1696.                         {
  1697.                             strcpy(LastPhone,FileName);
  1698.  
  1699.                             PhonebookChanged = FALSE;
  1700.  
  1701.                             RebuildMenu = TRUE;
  1702.                         }
  1703.                     }
  1704.                 }
  1705.  
  1706.                 break;
  1707.             }
  1708.  
  1709.             ReleaseWindows();
  1710.         }
  1711.         else
  1712.             Results[0] = RC_WARN;
  1713.     }
  1714.  
  1715.     return(NULL);
  1716. }
  1717.  
  1718. STRPTR
  1719. RexxOpenDevice(struct RexxPkt *Pkt)
  1720. {
  1721.     enum    {    ARG_OPENDEVICE_NAME,ARG_OPENDEVICE_UNIT };
  1722.  
  1723.     if(ReadRequest)
  1724.     {
  1725.         Results[0] = RC_ERROR;
  1726.         Results[1] = TERMERROR_DEVICE_DRIVER_STILL_OPEN;
  1727.     }
  1728.     else
  1729.     {
  1730.         if(Args[ARG_OPENDEVICE_NAME])
  1731.         {
  1732.             strcpy(Config -> SerialConfig -> SerialDevice,Args[ARG_OPENDEVICE_NAME]);
  1733.  
  1734.             ConfigChanged = TRUE;
  1735.         }
  1736.  
  1737.         if(Args[ARG_OPENDEVICE_UNIT])
  1738.         {
  1739.             Config -> SerialConfig -> UnitNumber = *(LONG *)Args[ARG_OPENDEVICE_UNIT];
  1740.  
  1741.             ConfigChanged = TRUE;
  1742.         }
  1743.  
  1744.         BlockWindows();
  1745.  
  1746.         ReopenSerial();
  1747.  
  1748.         ReleaseWindows();
  1749.     }
  1750.  
  1751.     return(NULL);
  1752. }
  1753.  
  1754. STRPTR
  1755. RexxOpenRequester(struct RexxPkt *Pkt)
  1756. {
  1757.     enum    {    ARG_OPENREQUESTER_REQUESTER };
  1758.  
  1759.     WORD Index;
  1760.  
  1761.     if((Index = ToRequester(Args[ARG_OPENREQUESTER_REQUESTER])) == -1)
  1762.     {
  1763.         Results[0] = RC_ERROR;
  1764.         Results[1] = ERROR_OBJECT_NOT_FOUND;
  1765.     }
  1766.     else
  1767.     {
  1768.         ULONG    Code;
  1769.         WORD    i;
  1770.  
  1771.         switch(Index)
  1772.         {
  1773.             case REQUESTER_SERIAL:
  1774.  
  1775.                 Code = MEN_SERIAL;
  1776.                 break;
  1777.  
  1778.             case REQUESTER_MODEM:
  1779.  
  1780.                 Code = MEN_MODEM;
  1781.                 break;
  1782.  
  1783.             case REQUESTER_SCREEN:
  1784.  
  1785.                 Code = MEN_SCREEN;
  1786.                 break;
  1787.  
  1788.             case REQUESTER_TERMINAL:
  1789.  
  1790.                 Code = MEN_TERMINAL;
  1791.                 break;
  1792.  
  1793.             case REQUESTER_EMULATION:
  1794.  
  1795.                 Code = MEN_SET_EMULATION;
  1796.                 break;
  1797.  
  1798.             case REQUESTER_CLIPBOARD:
  1799.  
  1800.                 Code = MEN_CLIPBOARD;
  1801.                 break;
  1802.  
  1803.             case REQUESTER_CAPTURE:
  1804.  
  1805.                 Code = MEN_CAPTURE;
  1806.                 break;
  1807.  
  1808.             case REQUESTER_COMMANDS:
  1809.  
  1810.                 Code = MEN_COMMANDS;
  1811.                 break;
  1812.  
  1813.             case REQUESTER_MISC:
  1814.  
  1815.                 Code = MEN_MISC;
  1816.                 break;
  1817.  
  1818.             case REQUESTER_PATH:
  1819.  
  1820.                 Code = MEN_PATH;
  1821.                 break;
  1822.  
  1823.             case REQUESTER_TRANSFER:
  1824.  
  1825.                 Code = MEN_TRANSFER;
  1826.                 break;
  1827.  
  1828.             case REQUESTER_TRANSLATIONS:
  1829.  
  1830.                 Code = MEN_TRANSLATION;
  1831.                 break;
  1832.  
  1833.             case REQUESTER_FUNCTIONKEYS:
  1834.  
  1835.                 Code = MEN_MACROS;
  1836.                 break;
  1837.  
  1838.             case REQUESTER_CURSORKEYS:
  1839.  
  1840.                 Code = MEN_CURSORKEYS;
  1841.                 break;
  1842.  
  1843.             case REQUESTER_FASTMACROS:
  1844.  
  1845.                 Code = MEN_FAST_MACROS;
  1846.                 break;
  1847.  
  1848.             case REQUESTER_HOTKEYS:
  1849.  
  1850.                 Code = MEN_HOTKEYS;
  1851.                 break;
  1852.  
  1853.             case REQUESTER_SPEECH:
  1854.  
  1855.                 Code = MEN_SPEECH;
  1856.                 break;
  1857.  
  1858.             case REQUESTER_SOUND:
  1859.  
  1860.                 Code = MEN_SOUND;
  1861.                 break;
  1862.  
  1863.  
  1864.             case REQUESTER_PHONE:
  1865.  
  1866.                 Code = MEN_PHONEBOOK;
  1867.                 break;
  1868.         }
  1869.  
  1870.             /* Scan the menu list... */
  1871.  
  1872.         for(i = 0 ; TermMenu[i] . nm_Type != NM_END ; i++)
  1873.         {
  1874.                 /* Did we get a valid name string? */
  1875.  
  1876.             if(TermMenu[i] . nm_Label != NM_BARLABEL)
  1877.             {
  1878.                 if((ULONG)TermMenu[i] . nm_UserData == Code)
  1879.                 {
  1880.                     HandleMenuCode((ULONG)TermMenu[i] . nm_UserData,NULL);
  1881.  
  1882.                     break;
  1883.                 }
  1884.             }
  1885.         }
  1886.     }
  1887.  
  1888.     return(NULL);
  1889. }
  1890.  
  1891. STRPTR
  1892. RexxParity(struct RexxPkt *Pkt)
  1893. {
  1894.     enum    {    ARG_PARITY_EVEN,ARG_PARITY_ODD,ARG_PARITY_NONE,ARG_PARITY_MARK,ARG_PARITY_SPACE };
  1895.  
  1896.     BYTE Mode;
  1897.  
  1898.     if(Args[ARG_PARITY_EVEN])
  1899.         Mode = PARITY_EVEN;
  1900.  
  1901.     if(Args[ARG_PARITY_ODD])
  1902.         Mode = PARITY_ODD;
  1903.  
  1904.     if(Args[ARG_PARITY_NONE])
  1905.         Mode = PARITY_NONE;
  1906.  
  1907.     if(Args[ARG_PARITY_MARK])
  1908.         Mode = PARITY_MARK;
  1909.  
  1910.     if(Args[ARG_PARITY_SPACE])
  1911.         Mode = PARITY_SPACE;
  1912.  
  1913.     if(Config -> SerialConfig -> Parity != Mode)
  1914.     {
  1915.         Config -> SerialConfig -> Parity = Mode;
  1916.  
  1917.         UpdateRequired = TRUE;
  1918.  
  1919.         ConfigChanged = TRUE;
  1920.     }
  1921.  
  1922.     return(NULL);
  1923. }
  1924.  
  1925. STRPTR
  1926. RexxPasteClip(struct RexxPkt *Pkt)
  1927. {
  1928.     enum    {    ARG_PASTECLIP_UNIT };
  1929.  
  1930.     struct DataMsg    *Msg;
  1931.     LONG         Unit;
  1932.  
  1933.     if(Args[ARG_PASTECLIP_UNIT])
  1934.         Unit = *(LONG *)Args[ARG_PASTECLIP_UNIT];
  1935.     else
  1936.         Unit = Config -> ClipConfig -> ClipboardUnit;
  1937.  
  1938.     if(Msg = (struct DataMsg *)CreateMsgItem(sizeof(struct DataMsg)))
  1939.     {
  1940.         Msg -> Type = DATAMSGTYPE_WRITECLIP;
  1941.         Msg -> Size = Unit;
  1942.  
  1943.         PutMsgItem(SpecialQueue,(struct MsgItem *)Msg);
  1944.     }
  1945.     else
  1946.     {
  1947.         Results[0] = RC_ERROR;
  1948.         Results[1] = ERROR_NO_FREE_STORE;
  1949.     }
  1950.  
  1951.     return(NULL);
  1952. }
  1953.  
  1954. STRPTR
  1955. RexxPrint(struct RexxPkt *Pkt)
  1956. {
  1957.     enum    {    ARG_PRINT_FROM,ARG_PRINT_TO,ARG_PRINT_SERIAL,ARG_PRINT_MODEM,ARG_PRINT_SCREEN,
  1958.             ARG_PRINT_TERMINAL,ARG_PRINT_USER,ARG_PRINT_COMMENT,ARG_PRINT_SIZE,
  1959.             ARG_PRINT_DATE,ARG_PRINT_BITS };
  1960.  
  1961.     WORD    Index,Mode = -1;
  1962.     ULONG    Flags = NULL;
  1963.  
  1964.     if(Args[ARG_PRINT_SERIAL])
  1965.         Flags |= PRINT_SERIAL;
  1966.  
  1967.     if(Args[ARG_PRINT_MODEM])
  1968.         Flags |= PRINT_MODEM;
  1969.  
  1970.     if(Args[ARG_PRINT_SCREEN])
  1971.         Flags |= PRINT_SCREEN;
  1972.  
  1973.     if(Args[ARG_PRINT_TERMINAL])
  1974.         Flags |= PRINT_TERMINAL;
  1975.  
  1976.     if(Args[ARG_PRINT_USER])
  1977.         Flags |= PRINT_USERNAME;
  1978.  
  1979.     if(Args[ARG_PRINT_COMMENT])
  1980.         Flags |= PRINT_COMMENT;
  1981.  
  1982.     if(Args[ARG_PRINT_SIZE])
  1983.         Flags |= PRINT_SIZE;
  1984.  
  1985.     if(Args[ARG_PRINT_DATE])
  1986.         Flags |= PRINT_DATE;
  1987.  
  1988.     if(Args[ARG_PRINT_BITS])
  1989.         Flags |= PRINT_BITS;
  1990.  
  1991.     if((Index = ToList(Args[ARG_PRINT_FROM])) == -1)
  1992.     {
  1993.         if(!Stricmp(Args[ARG_PRINT_FROM],"SCREENTEXT"))
  1994.         {
  1995.             if(!RasterEnabled)
  1996.             {
  1997.                 Results[0] = RC_ERROR;
  1998.                 Results[1] = TERMERROR_NO_DATA_TO_PROCESS;
  1999.  
  2000.                 return(NULL);
  2001.             }
  2002.             else
  2003.                 Mode = 0;
  2004.         }
  2005.  
  2006.         if(!Stricmp(Args[ARG_PRINT_FROM],"CLIPBOARD"))
  2007.             Mode = 1;
  2008.  
  2009.         if(!Stricmp(Args[ARG_PRINT_FROM],"BUFFER"))
  2010.             Mode = 2;
  2011.     }
  2012.  
  2013.     if(Index == -1 && Mode == -1)
  2014.     {
  2015.         Results[0] = RC_ERROR;
  2016.         Results[1] = TERMERROR_UNKNOWN_LIST;
  2017.     }
  2018.     else
  2019.     {
  2020.         BYTE    Continue = TRUE;
  2021.         LONG    Error = 0;
  2022.         BPTR    File;
  2023.         STRPTR    Name;
  2024.  
  2025.         if(Args[ARG_PRINT_TO])
  2026.             Name = Args[ARG_PRINT_TO];
  2027.         else
  2028.             Name = "PRT:";
  2029.  
  2030.         if(File = Open(Name,MODE_NEWFILE))
  2031.         {
  2032.             struct Window        *ReqWindow;
  2033.             struct EasyStruct     Easy;
  2034.  
  2035.             Easy . es_StructSize    = sizeof(struct EasyStruct);
  2036.             Easy . es_Flags        = NULL;
  2037.             Easy . es_Title        = (UBYTE *)LocaleString(MSG_TERMAUX_TERM_REQUEST_TXT);
  2038.             Easy . es_GadgetFormat    = (UBYTE *)LocaleString(MSG_PRINT_STOP_TXT);
  2039.             Easy . es_TextFormat    = (UBYTE *)LocaleString(MSG_GLOBAL_PRINTING_TXT);
  2040.  
  2041.             BlockWindows();
  2042.  
  2043.             if(ReqWindow = BuildEasyRequest(Window,&Easy,NULL))
  2044.             {
  2045.                 switch(Index)
  2046.                 {
  2047.                     case GLIST_DIAL:
  2048.                     {
  2049.                         struct GenericList *List = GenericListTable[Index];
  2050.  
  2051.                         ObtainSemaphore(&List -> ListSemaphore);
  2052.  
  2053.                         if(List -> ListHeader . mlh_Head -> mln_Succ)
  2054.                         {
  2055.                             struct DialNode *TempNode;
  2056.  
  2057.                             for(TempNode = (struct DialNode *)List -> ListHeader . mlh_Head ; Continue && TempNode -> Node . ln_Succ ; TempNode = (struct DialNode *)TempNode -> Node . ln_Succ)
  2058.                             {
  2059.                                 if(TempNode -> Entry)
  2060.                                     Continue = PrintEntry(File,ReqWindow,TRUE,&Error,TempNode -> Entry,Flags);
  2061.                                 else
  2062.                                     Continue = PrintText(File,ReqWindow,&Error,"\n\"???\" (%s)",TempNode -> Node . ln_Name);
  2063.                             }
  2064.                         }
  2065.  
  2066.                         ReleaseSemaphore(&List -> ListSemaphore);
  2067.                     }
  2068.  
  2069.                     break;
  2070.  
  2071.                     case GLIST_UPLOAD:
  2072.                     case GLIST_DOWNLOAD:
  2073.                     {
  2074.                         struct GenericList *List = GenericListTable[Index];
  2075.  
  2076.                         ObtainSemaphore(&List -> ListSemaphore);
  2077.  
  2078.                         if(List -> ListHeader . mlh_Head -> mln_Succ)
  2079.                         {
  2080.                             struct Node *TempNode;
  2081.  
  2082.                             for(TempNode = (struct Node *)List -> ListHeader . mlh_Head ; Continue && TempNode -> ln_Succ ; TempNode = TempNode -> ln_Succ)
  2083.                                 Continue = PrintFileInformation(File,ReqWindow,&Error,TempNode -> ln_Name,Flags);
  2084.                         }
  2085.  
  2086.                         ReleaseSemaphore(&List -> ListSemaphore);
  2087.                     }
  2088.  
  2089.                     break;
  2090.  
  2091.                     case GLIST_WAIT:
  2092.                     {
  2093.                         struct GenericList *List = GenericListTable[Index];
  2094.  
  2095.                         ObtainSemaphore(&List -> ListSemaphore);
  2096.  
  2097.                         if(List -> ListHeader . mlh_Head -> mln_Succ)
  2098.                         {
  2099.                             struct Node *TempNode;
  2100.  
  2101.                             for(TempNode = (struct Node *)List -> ListHeader . mlh_Head ; Continue && TempNode -> ln_Succ ; TempNode = TempNode -> ln_Succ)
  2102.                                 Continue = PrintText(File,ReqWindow,&Error,"%s\n",TempNode -> ln_Name);
  2103.                         }
  2104.  
  2105.                         ReleaseSemaphore(&List -> ListSemaphore);
  2106.                     }
  2107.  
  2108.                     break;
  2109.  
  2110.                     default:
  2111.                     {
  2112.                         switch(Mode)
  2113.                         {
  2114.                             case 0:
  2115.  
  2116.                                 Continue = PrintScreen(File,ReqWindow,&Error);
  2117.                                 break;
  2118.  
  2119.                             case 1:
  2120.  
  2121.                                 Continue = PrintClip(File,ReqWindow,&Error);
  2122.                                 break;
  2123.  
  2124.                             case 2:
  2125.  
  2126.                                 Continue = PrintBuffer(File,ReqWindow,&Error);
  2127.                                 break;
  2128.                         }
  2129.  
  2130.                         break;
  2131.                     }
  2132.  
  2133.                     break;
  2134.                 }
  2135.  
  2136.                 FreeSysRequest(ReqWindow);
  2137.             }
  2138.  
  2139.             ReleaseWindows();
  2140.  
  2141.             Close(File);
  2142.         }
  2143.         else
  2144.             Error = IoErr();
  2145.  
  2146.         if(Error)
  2147.         {
  2148.             Results[0] = RC_ERROR;
  2149.             Results[1] = Error;
  2150.         }
  2151.         else
  2152.         {
  2153.             if(!Continue)
  2154.                 Results[0] = RC_WARN;
  2155.         }
  2156.     }
  2157.  
  2158.     return(NULL);
  2159. }
  2160.  
  2161. STRPTR
  2162. RexxProcessIO(struct RexxPkt *Pkt)
  2163. {
  2164.     enum    {    ARG_PROCESSIO_ON,ARG_PROCESSIO_OFF };
  2165.  
  2166.     Forbid();
  2167.  
  2168.     if(Args[ARG_PROCESSIO_ON])
  2169.         ProcessIO = TRUE;
  2170.  
  2171.     if(Args[ARG_PROCESSIO_OFF])
  2172.         ProcessIO = FALSE;
  2173.  
  2174.     Permit();
  2175.  
  2176.     return(NULL);
  2177. }
  2178.  
  2179. STRPTR
  2180. RexxProtocol(struct RexxPkt *Pkt)
  2181. {
  2182.     enum    {    ARG_PROTOCOL_NONE,ARG_PROTOCOL_RTSCTS,ARG_PROTOCOL_RTSCTSDTR };
  2183.  
  2184.     BYTE Mode;
  2185.  
  2186.     if(Args[ARG_PROTOCOL_NONE])
  2187.         Mode = HANDSHAKING_NONE;
  2188.  
  2189.     if(Args[ARG_PROTOCOL_RTSCTS])
  2190.         Mode = HANDSHAKING_RTSCTS;
  2191.  
  2192.     if(Args[ARG_PROTOCOL_RTSCTSDTR])
  2193.         Mode = HANDSHAKING_RTSCTS_DSR;
  2194.  
  2195.     if(Config -> SerialConfig -> HandshakingProtocol != Mode)
  2196.     {
  2197.         Config -> SerialConfig -> HandshakingProtocol = Mode;
  2198.  
  2199.         UpdateRequired = TRUE;
  2200.  
  2201.         ConfigChanged = TRUE;
  2202.     }
  2203.  
  2204.     return(NULL);
  2205. }
  2206.  
  2207. STRPTR
  2208. RexxPutClip(struct RexxPkt *Pkt)
  2209. {
  2210.     enum    {    ARG_PUTCLIP_UNIT,ARG_PUTCLIP_TEXT };
  2211.  
  2212.     struct IFFHandle    *Handle;
  2213.     LONG             Unit;
  2214.     BYTE             Success = FALSE;
  2215.  
  2216.     if(Args[ARG_PUTCLIP_UNIT])
  2217.         Unit = *(LONG *)Args[ARG_PUTCLIP_UNIT];
  2218.     else
  2219.         Unit = Config -> ClipConfig -> ClipboardUnit;
  2220.  
  2221.     if(Handle = AllocIFF())
  2222.     {
  2223.         if(Handle -> iff_Stream = (ULONG)OpenClipboard(Unit))
  2224.         {
  2225.             InitIFFasClip(Handle);
  2226.  
  2227.             if(!OpenIFF(Handle,IFFF_WRITE))
  2228.             {
  2229.                 if(!PushChunk(Handle,ID_FTXT,ID_FORM,IFFSIZE_UNKNOWN))
  2230.                 {
  2231.                     if(!PushChunk(Handle,0,ID_CHRS,IFFSIZE_UNKNOWN))
  2232.                     {
  2233.                         LONG Len = strlen(Args[ARG_PUTCLIP_TEXT]);
  2234.  
  2235.                         if(WriteChunkBytes(Handle,Args[ARG_PUTCLIP_TEXT],Len) == Len)
  2236.                         {
  2237.                             if(!PopChunk(Handle))
  2238.                                 Success = TRUE;
  2239.                         }
  2240.                     }
  2241.                 }
  2242.  
  2243.                 if(PopChunk(Handle))
  2244.                     Success = FALSE;
  2245.  
  2246.                 CloseIFF(Handle);
  2247.             }
  2248.             else
  2249.             {
  2250.                 Results[0] = RC_ERROR;
  2251.                 Results[1] = ERROR_NO_FREE_STORE;
  2252.             }
  2253.  
  2254.             CloseClipboard((struct ClipboardHandle *)Handle -> iff_Stream);
  2255.         }
  2256.         else
  2257.         {
  2258.             Results[0] = RC_ERROR;
  2259.             Results[1] = TERMERROR_UNIT_NOT_AVAILABLE;
  2260.         }
  2261.  
  2262.         FreeIFF(Handle);
  2263.     }
  2264.     else
  2265.     {
  2266.         Results[0] = RC_ERROR;
  2267.         Results[1] = ERROR_NO_FREE_STORE;
  2268.     }
  2269.  
  2270.     if(!Success && !Results[0])
  2271.     {
  2272.         Results[0] = RC_ERROR;
  2273.         Results[1] = TERMERROR_CLIPBOARD_ERROR;
  2274.     }
  2275.  
  2276.     return(NULL);
  2277. }
  2278.  
  2279. STRPTR
  2280. RexxQuit(struct RexxPkt *Pkt)
  2281. {
  2282.     enum    {    ARG_QUIT_FORCE };
  2283.  
  2284.     struct DataMsg *Msg;
  2285.  
  2286.     if(Msg = (struct DataMsg *)CreateMsgItem(sizeof(struct DataMsg)))
  2287.     {
  2288.         Pkt -> RexxMsg -> rm_Result1 = RC_WARN;
  2289.         Pkt -> RexxMsg -> rm_Result2 = 0;
  2290.  
  2291.         ReplyMsg(Pkt -> RexxMsg);
  2292.  
  2293.         Pkt -> RexxMsg = NULL;
  2294.  
  2295.         Msg -> Type = DATAMSGTYPE_MENU;
  2296.         Msg -> Size = MEN_QUIT;
  2297.  
  2298.         if(Args[ARG_QUIT_FORCE])
  2299.             Msg -> Data = (APTR)(IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT);
  2300.         else
  2301.             Msg -> Data = NULL;
  2302.  
  2303.         PutMsgItem(SpecialQueue,(struct MsgItem *)Msg);
  2304.     }
  2305.     else
  2306.     {
  2307.         Results[0] = RC_ERROR;
  2308.         Results[1] = ERROR_NO_FREE_STORE;
  2309.     }
  2310.  
  2311.     return(NULL);
  2312. }
  2313.  
  2314. STATIC STRPTR    RexxReadBuffer;
  2315. STATIC LONG    RexxReadIndex,
  2316.         RexxReadLen;
  2317. STATIC BYTE    RexxReadDone,
  2318.         RexxReadEcho;
  2319.  
  2320. STATIC BOOLEAN
  2321. RexxReadBypassVerbatim(STRPTR Buffer,LONG Size)
  2322. {
  2323.     while(Size-- > 0)
  2324.     {
  2325.         switch(*Buffer)
  2326.         {
  2327.             case '\n':
  2328.  
  2329.                 break;
  2330.  
  2331.             case '\r':
  2332.  
  2333.                 RexxReadDone = TRUE;
  2334.                 break;
  2335.  
  2336.             case '\b':
  2337.             case '\30':
  2338.  
  2339.                 while(RexxReadIndex > 0)
  2340.                 {
  2341.                     if(RexxReadEcho)
  2342.                         SerWriteVerbatim("\b",1,FALSE);
  2343.  
  2344.                     RexxReadIndex--;
  2345.                 }
  2346.  
  2347.                 break;
  2348.  
  2349.             default:
  2350.  
  2351.                 if(RexxReadIndex < RexxReadLen && ((*Buffer >= ' ' && *Buffer < 127) || *Buffer >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  2352.                 {
  2353.                     RexxReadBuffer[RexxReadIndex++] = *Buffer;
  2354.  
  2355.                     if(RexxReadEcho)
  2356.                         SerWriteVerbatim(Buffer,1,FALSE);
  2357.                 }
  2358.  
  2359.                 break;
  2360.         }
  2361.  
  2362.         Buffer++;
  2363.     }
  2364.  
  2365.     return(FALSE);
  2366. }
  2367.  
  2368. STATIC BOOLEAN
  2369. RexxReadBypassTranslate(STRPTR Buffer,LONG Size)
  2370. {
  2371.     struct TranslationHandle    Handle;
  2372.     UBYTE                Temp;
  2373.  
  2374.     while(Size-- > 0)
  2375.     {
  2376.         TranslateSetup(&Handle,Buffer,1,&Temp,1,ReceiveTable);
  2377.  
  2378.         while(!RexxReadDone && TranslateBuffer(&Handle))
  2379.         {
  2380.             switch(Temp)
  2381.             {
  2382.                 case '\n':
  2383.     
  2384.                     break;
  2385.     
  2386.                 case '\r':
  2387.     
  2388.                     RexxReadDone = TRUE;
  2389.     
  2390.                     break;
  2391.     
  2392.                 case '\b':
  2393.                 case '\30':
  2394.     
  2395.                     while(RexxReadIndex > 0)
  2396.                     {
  2397.                         if(RexxReadEcho)
  2398.                             SerWriteVerbatim("\b",1,FALSE);
  2399.  
  2400.                         RexxReadIndex--;
  2401.                     }
  2402.  
  2403.                     break;
  2404.     
  2405.                 default:
  2406.     
  2407.                     if(RexxReadIndex < RexxReadLen && ((Temp >= ' ' && Temp < 127) || Temp >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  2408.                     {
  2409.                         RexxReadBuffer[RexxReadIndex++] = Temp;
  2410.  
  2411.                         if(RexxReadEcho)
  2412.                             SerWriteVerbatim(&Temp,1,FALSE);
  2413.                     }
  2414.     
  2415.                     break;
  2416.             }
  2417.         }
  2418.  
  2419.         Buffer++;
  2420.     }
  2421.  
  2422.     return(FALSE);
  2423. }
  2424.  
  2425. STRPTR
  2426. RexxRead(struct RexxPkt *Pkt)
  2427. {
  2428.     enum    {    ARG_READ_NUM,ARG_READ_CR,ARG_READ_NOECHO,ARG_READ_VERBATIM,ARG_READ_PROMPT };
  2429.  
  2430.     LONG Len,BytesRead = 0;
  2431.  
  2432.     if(!ReadRequest || !WriteRequest)
  2433.     {
  2434.         Results[0] = RC_WARN;
  2435.  
  2436.         return(NULL);
  2437.     }
  2438.  
  2439.     if(Args[ARG_READ_NUM])
  2440.     {
  2441.         Len = *(LONG *)Args[ARG_READ_NUM] + 1;
  2442.  
  2443.         if(Len < 1)
  2444.         {
  2445.             Results[0] = RC_ERROR;
  2446.             Results[1] = ERROR_BAD_NUMBER;
  2447.  
  2448.             return(NULL);
  2449.         }
  2450.  
  2451.         if(Len > MAX_RESULT_LEN + 1)
  2452.             Len = MAX_RESULT_LEN + 1;
  2453.     }
  2454.     else
  2455.         Len = MAX_RESULT_LEN + 1;
  2456.  
  2457.     if(Args[ARG_READ_PROMPT])
  2458.         SerialCommand(Args[ARG_READ_PROMPT]);
  2459.  
  2460.     if(Marking)
  2461.         DropMarker();
  2462.  
  2463.     BlockWindows();
  2464.  
  2465.     if(Args[ARG_READ_CR])
  2466.     {
  2467.         Forbid();
  2468.  
  2469.         LT_UnlockWindow(Window);
  2470.  
  2471.         Window -> Flags |= WFLG_RMBTRAP;
  2472.  
  2473.         Permit();
  2474.  
  2475.         NormalCursor();
  2476.     }
  2477.  
  2478.     Status = STATUS_READY;
  2479.  
  2480.     if(Args[ARG_READ_VERBATIM] || !ReceiveTable)
  2481.     {
  2482.         if(Args[ARG_READ_CR])
  2483.         {
  2484.             ULONG     Signals,SignalMask = SIG_SERIAL | SIG_TIMER | SIG_BREAK;
  2485.             UBYTE    *Char = ReadBuffer;
  2486.             BYTE     Echo,Done = FALSE;
  2487.             LONG     Index = 0;
  2488.             STRPTR     Buffer;
  2489.  
  2490.             if(Buffer = (STRPTR)AllocVecPooled(Len,MEMF_ANY))
  2491.             {
  2492.                 if(Args[ARG_READ_NOECHO])
  2493.                     Echo = FALSE;
  2494.                 else
  2495.                     Echo = TRUE;
  2496.  
  2497.                 RexxReadEcho = Echo;
  2498.  
  2499.                 if(RexxTimeoutVal)
  2500.                     StartTime(RexxTimeoutVal,0);
  2501.  
  2502.                 if(DataHold)
  2503.                 {
  2504.                     while(DataSize-- > 0)
  2505.                     {
  2506.                         Char = DataHold++;
  2507.  
  2508.                         switch(*Char)
  2509.                         {
  2510.                             case '\n':
  2511.  
  2512.                                 break;
  2513.  
  2514.                             case '\r':
  2515.  
  2516.                                 Done = TRUE;
  2517.  
  2518.                                 if(Echo)
  2519.                                     SerWrite(ReadBuffer,1);
  2520.  
  2521.                                 break;
  2522.  
  2523.                             case '\b':
  2524.  
  2525.                                 if(Index > 0)
  2526.                                 {
  2527.                                     Index--;
  2528.  
  2529.                                     if(Echo)
  2530.                                         SerWrite(ReadBuffer,1);
  2531.                                 }
  2532.  
  2533.                                 break;
  2534.  
  2535.                             case '\30':
  2536.  
  2537.                                 if(Echo)
  2538.                                 {
  2539.                                     while(Index > 0)
  2540.                                     {
  2541.                                         Index--;
  2542.  
  2543.                                         SerWrite("\b",1);
  2544.                                     }
  2545.                                 }
  2546.                                 else
  2547.                                     Index = 0;
  2548.  
  2549.                                 break;
  2550.  
  2551.                             default:
  2552.  
  2553.                                 if(Index < Len && ((*Char >= ' ' && *Char < 127) || *Char >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  2554.                                 {
  2555.                                     Buffer[Index++] = *Char;
  2556.  
  2557.                                     if(Echo)
  2558.                                         SerWrite(ReadBuffer,1);
  2559.                                 }
  2560.  
  2561.                                 break;
  2562.                         }
  2563.                     }
  2564.  
  2565.                     DataHold = NULL;
  2566.  
  2567.                     RestartSerial(TRUE);
  2568.                 }
  2569.  
  2570.                 if(CheckIO(ReadRequest))
  2571.                     Signals = SIG_SERIAL;
  2572.                 else
  2573.                     Signals = NULL;
  2574.  
  2575.                 do
  2576.                 {
  2577.                     if(Signals & SIG_WINDOW)
  2578.                     {
  2579.                         SerWriteBypass = RexxReadBypassVerbatim;
  2580.  
  2581.                         RexxReadBuffer    = Buffer;
  2582.                         RexxReadIndex    = Index;
  2583.                         RexxReadLen    = Len;
  2584.                         RexxReadDone    = Done;
  2585.  
  2586.                         while(HandleWindow());
  2587.  
  2588.                         Buffer    = RexxReadBuffer;
  2589.                         Index    = RexxReadIndex;
  2590.                         Len    = RexxReadLen;
  2591.                         Done    = RexxReadDone;
  2592.  
  2593.                         SerWriteBypass = NULL;
  2594.                     }
  2595.  
  2596.                     if(Signals & SIG_SERIAL)
  2597.                     {
  2598.                         if(!WaitIO(ReadRequest))
  2599.                         {
  2600.                             BytesIn++;
  2601.  
  2602.                             switch(*Char)
  2603.                             {
  2604.                                 case '\n':
  2605.  
  2606.                                     break;
  2607.  
  2608.                                 case '\r':
  2609.  
  2610.                                     Done = TRUE;
  2611.  
  2612.                                     if(Echo)
  2613.                                         SerWrite(ReadBuffer,1);
  2614.  
  2615.                                     break;
  2616.  
  2617.                                 case '\b':
  2618.  
  2619.                                     if(Index > 0)
  2620.                                     {
  2621.                                         Index--;
  2622.  
  2623.                                         if(Echo)
  2624.                                             SerWrite(ReadBuffer,1);
  2625.                                     }
  2626.  
  2627.                                     break;
  2628.  
  2629.                                 case '\30':
  2630.  
  2631.                                     if(Echo)
  2632.                                     {
  2633.                                         while(Index > 0)
  2634.                                         {
  2635.                                             Index--;
  2636.  
  2637.                                             SerWrite("\b",1);
  2638.                                         }
  2639.                                     }
  2640.                                     else
  2641.                                         Index = 0;
  2642.  
  2643.                                 default:
  2644.  
  2645.                                     if(Index < Len && ((*Char >= ' ' && *Char < 127) || *Char >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  2646.                                     {
  2647.                                         Buffer[Index++] = *Char;
  2648.  
  2649.                                         if(Echo)
  2650.                                             SerWrite(ReadBuffer,1);
  2651.                                     }
  2652.  
  2653.                                     break;
  2654.                             }
  2655.                         }
  2656.  
  2657.                         RestartSerial(TRUE);
  2658.                     }
  2659.  
  2660.                     if(Signals & (SIG_BREAK | SIG_TIMER))
  2661.                     {
  2662.                         Results[0] = RC_WARN;
  2663.  
  2664.                         break;
  2665.                     }
  2666.  
  2667.                     if(!Done)
  2668.                         Signals = Wait(SignalMask | SIG_WINDOW);
  2669.                 }
  2670.                 while(!Done);
  2671.  
  2672.                 if(RexxTimeoutVal)
  2673.                     StopTime();
  2674.  
  2675.                 if(Index)
  2676.                 {
  2677.                     STRPTR Result;
  2678.  
  2679.                     Buffer[Index] = 0;
  2680.  
  2681.                     Result = CreateResult(Buffer,Results);
  2682.  
  2683.                     if(Args[ARG_READ_CR])
  2684.                     {
  2685.                         Forbid();
  2686.  
  2687.                         Window -> Flags &= ~WFLG_RMBTRAP;
  2688.  
  2689.                         LT_LockWindow(Window);
  2690.  
  2691.                         Permit();
  2692.                     }
  2693.  
  2694.                     ReleaseWindows();
  2695.  
  2696.                     FreeVecPooled(Buffer);
  2697.  
  2698.                     return(Result);
  2699.                 }
  2700.                 else
  2701.                     Results[0] = RC_WARN;
  2702.  
  2703.                 FreeVecPooled(Buffer);
  2704.             }
  2705.             else
  2706.             {
  2707.                 Results[0] = RC_ERROR;
  2708.                 Results[1] = ERROR_NO_FREE_STORE;
  2709.             }
  2710.         }
  2711.         else
  2712.         {
  2713.             STRPTR Buffer;
  2714.  
  2715.             if(Buffer = (STRPTR)AllocVecPooled(Len,MEMF_ANY))
  2716.             {
  2717.                 STRPTR Result;
  2718.  
  2719.                 if(DataHold && DataSize >= Len - 1)
  2720.                 {
  2721.                     CopyMem(DataHold,Buffer,Len - 1);
  2722.  
  2723.                     BytesRead = Len - 1;
  2724.  
  2725.                     if(DataSize == Len - 1)
  2726.                     {
  2727.                         DataHold = NULL;
  2728.  
  2729.                         RestartSerial(TRUE);
  2730.                     }
  2731.                     else
  2732.                     {
  2733.                         DataHold += Len - 1;
  2734.                         DataSize -= Len - 1;
  2735.                     }
  2736.                 }
  2737.                 else
  2738.                 {
  2739.                     ULONG Signals,SignalMask = SIG_SERIAL | SIG_TIMER | SIG_BREAK;
  2740.  
  2741.                     ClearSerial();
  2742.  
  2743.                     if(DataHold)
  2744.                     {
  2745.                         CopyMem(DataHold,Buffer,DataSize);
  2746.  
  2747.                         ReadRequest -> IOSer . io_Data        = Buffer + DataSize;
  2748.                         ReadRequest -> IOSer . io_Length    = Len - 1 - DataSize;
  2749.  
  2750.                         BytesRead = DataSize;
  2751.  
  2752.                         DataHold = NULL;
  2753.                     }
  2754.                     else
  2755.                     {
  2756.                         ReadRequest -> IOSer . io_Data        = Buffer;
  2757.                         ReadRequest -> IOSer . io_Length    = Len - 1;
  2758.                     }
  2759.  
  2760.                     ReadRequest -> IOSer . io_Command = CMD_READ;
  2761.  
  2762.                     ClrSignal(SignalMask);
  2763.  
  2764.                     if(RexxTimeoutVal)
  2765.                         StartTime(RexxTimeoutVal,0);
  2766.  
  2767.                     SendIO(ReadRequest);
  2768.  
  2769.                     FOREVER
  2770.                     {
  2771.                         Signals = Wait(SignalMask);
  2772.  
  2773.                         if(Signals & SIG_SERIAL)
  2774.                         {
  2775.                             if(RexxTimeoutVal)
  2776.                                 StopTime();
  2777.  
  2778.                                 /* Did the request terminate gracefully? */
  2779.  
  2780.                             if(!WaitIO(ReadRequest))
  2781.                             {
  2782.                                 BytesIn += ReadRequest -> IOSer . io_Actual;
  2783.  
  2784.                                 BytesRead = ReadRequest -> IOSer . io_Actual;
  2785.                             }
  2786.                             else
  2787.                                 Results[0] = RC_ERROR;
  2788.  
  2789.                             break;
  2790.                         }
  2791.  
  2792.                         if(Signals & SIG_BREAK)
  2793.                         {
  2794.                             if(!CheckIO(ReadRequest))
  2795.                                 AbortIO(ReadRequest);
  2796.  
  2797.                             WaitIO(ReadRequest);
  2798.  
  2799.                             if(RexxTimeoutVal)
  2800.                                 StopTime();
  2801.  
  2802.                             Results[0] = RC_WARN;
  2803.  
  2804.                             break;
  2805.                         }
  2806.  
  2807.                         if(Signals & SIG_TIMER)
  2808.                         {
  2809.                             if(!CheckIO(ReadRequest))
  2810.                                 AbortIO(ReadRequest);
  2811.  
  2812.                             WaitIO(ReadRequest);
  2813.  
  2814.                             WaitIO(TimeRequest);
  2815.  
  2816.                             if(ReadRequest -> IOSer . io_Actual)
  2817.                             {
  2818.                                 BytesIn += ReadRequest -> IOSer . io_Actual;
  2819.  
  2820.                                 BytesRead = ReadRequest -> IOSer . io_Actual;
  2821.                             }
  2822.                             else
  2823.                             {
  2824.                                 WriteRequest -> IOSer . io_Command = SDCMD_QUERY;
  2825.  
  2826.                                 DoIO(WriteRequest);
  2827.  
  2828.                                 if(WriteRequest -> IOSer . io_Actual)
  2829.                                 {
  2830.                                         /* Don't read more than actually wanted. */
  2831.  
  2832.                                     ReadRequest -> IOSer . io_Command    = CMD_READ;
  2833.                                     ReadRequest -> IOSer . io_Data        = Buffer;
  2834.                                     ReadRequest -> IOSer . io_Length    = MIN(Len - 1,WriteRequest -> IOSer . io_Actual);
  2835.  
  2836.                                     if(!DoIO(ReadRequest))
  2837.                                     {
  2838.                                         BytesIn += ReadRequest -> IOSer . io_Actual;
  2839.  
  2840.                                         BytesRead = ReadRequest -> IOSer . io_Actual;
  2841.                                     }
  2842.                                 }
  2843.                             }
  2844.  
  2845.                             break;
  2846.                         }
  2847.                     }
  2848.                 }
  2849.  
  2850.                 if(BytesRead)
  2851.                     Result = CreateResultLen(Buffer,Results,BytesRead);
  2852.                 else
  2853.                 {
  2854.                     Results[0] = RC_WARN;
  2855.  
  2856.                     Result = NULL;
  2857.                 }
  2858.  
  2859.                 FreeVecPooled(Buffer);
  2860.  
  2861.                 RestartSerial(TRUE);
  2862.  
  2863.                 if(Args[ARG_READ_CR])
  2864.                 {
  2865.                     Forbid();
  2866.  
  2867.                     Window -> Flags &= ~WFLG_RMBTRAP;
  2868.  
  2869.                     LT_LockWindow(Window);
  2870.  
  2871.                     Permit();
  2872.                 }
  2873.  
  2874.                 ReleaseWindows();
  2875.  
  2876.                 return(Result);
  2877.             }
  2878.             else
  2879.             {
  2880.                 Results[0] = RC_ERROR;
  2881.                 Results[1] = ERROR_NO_FREE_STORE;
  2882.             }
  2883.  
  2884.             RestartSerial(TRUE);
  2885.         }
  2886.     }
  2887.     else
  2888.     {
  2889.         if(Args[ARG_READ_CR])
  2890.         {
  2891.             ULONG                 Signals,SignalMask = SIG_SERIAL | SIG_TIMER | SIG_BREAK;
  2892.             UBYTE                *Char = ReadBuffer,Temp;
  2893.             BYTE                 Echo,Done = FALSE;
  2894.             LONG                 Index = 0;
  2895.             struct TranslationHandle     Handle;
  2896.             STRPTR                 Buffer;
  2897.  
  2898.             if(Buffer = (STRPTR)AllocVecPooled(Len,MEMF_ANY))
  2899.             {
  2900.                 if(Args[ARG_READ_NOECHO])
  2901.                     Echo = FALSE;
  2902.                 else
  2903.                     Echo = TRUE;
  2904.  
  2905.                 RexxReadEcho = Echo;
  2906.  
  2907.                 if(RexxTimeoutVal)
  2908.                     StartTime(RexxTimeoutVal,0);
  2909.  
  2910.                 if(DataHold)
  2911.                 {
  2912.                     while(DataSize-- > 0)
  2913.                     {
  2914.                         Char = DataHold++;
  2915.  
  2916.                         TranslateSetup(&Handle,Char,1,&Temp,1,ReceiveTable);
  2917.  
  2918.                         while(!Done && TranslateBuffer(&Handle))
  2919.                         {
  2920.                             switch(Temp)
  2921.                             {
  2922.                                 case '\n':
  2923.  
  2924.                                     break;
  2925.  
  2926.                                 case '\r':
  2927.  
  2928.                                     Done = TRUE;
  2929.  
  2930.                                     if(Echo)
  2931.                                         SerWrite(&Temp,1);
  2932.  
  2933.                                     break;
  2934.  
  2935.                                 case '\b':
  2936.  
  2937.                                     if(Index > 0)
  2938.                                     {
  2939.                                         Index--;
  2940.  
  2941.                                         if(Echo)
  2942.                                             SerWrite(&Temp,1);
  2943.                                     }
  2944.  
  2945.                                     break;
  2946.  
  2947.                                 case '\30':
  2948.  
  2949.                                     if(Echo)
  2950.                                     {
  2951.                                         while(Index > 0)
  2952.                                         {
  2953.                                             Index--;
  2954.  
  2955.                                             SerWrite("\b",1);
  2956.                                         }
  2957.                                     }
  2958.                                     else
  2959.                                         Index = 0;
  2960.  
  2961.                                     break;
  2962.  
  2963.                                 default:
  2964.  
  2965.                                     if(Index < Len && ((Temp >= ' ' && Temp < 127) || Temp >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  2966.                                     {
  2967.                                         Buffer[Index++] = Temp;
  2968.  
  2969.                                         if(Echo)
  2970.                                             SerWrite(&Temp,1);
  2971.                                     }
  2972.  
  2973.                                     break;
  2974.                             }
  2975.                         }
  2976.                     }
  2977.  
  2978.                     DataHold = NULL;
  2979.  
  2980.                     RestartSerial(TRUE);
  2981.                 }
  2982.  
  2983.                 if(CheckIO(ReadRequest))
  2984.                     Signals = SIG_SERIAL;
  2985.                 else
  2986.                     Signals = NULL;
  2987.  
  2988.                 do
  2989.                 {
  2990.                     if(Signals & SIG_WINDOW)
  2991.                     {
  2992.                         SerWriteBypass = RexxReadBypassTranslate;
  2993.  
  2994.                         RexxReadBuffer    = Buffer;
  2995.                         RexxReadIndex    = Index;
  2996.                         RexxReadLen    = Len;
  2997.                         RexxReadDone    = Done;
  2998.  
  2999.                         while(HandleWindow());
  3000.  
  3001.                         Buffer    = RexxReadBuffer;
  3002.                         Index    = RexxReadIndex;
  3003.                         Len    = RexxReadLen;
  3004.                         Done    = RexxReadDone;
  3005.  
  3006.                         SerWriteBypass = NULL;
  3007.                     }
  3008.  
  3009.                     if(Signals & SIG_SERIAL)
  3010.                     {
  3011.                         if(!WaitIO(ReadRequest))
  3012.                         {
  3013.                             BytesIn++;
  3014.  
  3015.                             TranslateSetup(&Handle,Char,1,&Temp,1,ReceiveTable);
  3016.  
  3017.                             while(!Done && TranslateBuffer(&Handle))
  3018.                             {
  3019.                                 switch(Temp)
  3020.                                 {
  3021.                                     case '\n':
  3022.  
  3023.                                         break;
  3024.  
  3025.                                     case '\r':
  3026.  
  3027.                                         Done = TRUE;
  3028.  
  3029.                                         if(Echo)
  3030.                                             SerWrite(&Temp,1);
  3031.  
  3032.                                         break;
  3033.  
  3034.                                     case '\b':
  3035.  
  3036.                                         if(Index > 0)
  3037.                                         {
  3038.                                             Index--;
  3039.  
  3040.                                             if(Echo)
  3041.                                                 SerWrite(&Temp,1);
  3042.                                         }
  3043.  
  3044.                                         break;
  3045.  
  3046.                                     case '\30':
  3047.  
  3048.                                         if(Echo)
  3049.                                         {
  3050.                                             while(Index > 0)
  3051.                                             {
  3052.                                                 Index--;
  3053.  
  3054.                                                 SerWrite("\b",1);
  3055.                                             }
  3056.                                         }
  3057.                                         else
  3058.                                             Index = 0;
  3059.  
  3060.                                     default:
  3061.  
  3062.                                         if(Index < Len && ((Temp >= ' ' && Temp < 127) || Temp >= 160 || Config -> TerminalConfig -> FontMode == FONT_IBM))
  3063.                                         {
  3064.                                             Buffer[Index++] = Temp;
  3065.  
  3066.                                             if(Echo)
  3067.                                                 SerWrite(&Temp,1);
  3068.                                         }
  3069.  
  3070.                                         break;
  3071.                                 }
  3072.                             }
  3073.                         }
  3074.  
  3075.                         RestartSerial(TRUE);
  3076.                     }
  3077.  
  3078.                     if(Signals & (SIG_BREAK | SIG_TIMER))
  3079.                     {
  3080.                         Results[0] = RC_WARN;
  3081.  
  3082.                         break;
  3083.                     }
  3084.  
  3085.                     if(!Done)
  3086.                         Signals = Wait(SignalMask | SIG_WINDOW);
  3087.                 }
  3088.                 while(!Done);
  3089.  
  3090.                 if(RexxTimeoutVal)
  3091.                     StopTime();
  3092.  
  3093.                 if(Index)
  3094.                 {
  3095.                     STRPTR Result;
  3096.  
  3097.                     Buffer[Index] = 0;
  3098.  
  3099.                     Result = CreateResult(Buffer,Results);
  3100.  
  3101.                     if(Args[ARG_READ_CR])
  3102.                     {
  3103.                         Forbid();
  3104.     
  3105.                         Window -> Flags &= ~WFLG_RMBTRAP;
  3106.     
  3107.                         LT_LockWindow(Window);
  3108.     
  3109.                         Permit();
  3110.                     }
  3111.  
  3112.                     ReleaseWindows();
  3113.  
  3114.                     FreeVecPooled(Buffer);
  3115.  
  3116.                     return(Result);
  3117.                 }
  3118.                 else
  3119.                     Results[0] = RC_WARN;
  3120.  
  3121.                 FreeVecPooled(Buffer);
  3122.             }
  3123.             else
  3124.             {
  3125.                 Results[0] = RC_ERROR;
  3126.                 Results[1] = ERROR_NO_FREE_STORE;
  3127.             }
  3128.         }
  3129.         else
  3130.         {
  3131.             STRPTR Buffer;
  3132.  
  3133.             if(Buffer = (STRPTR)AllocVecPooled(Len,MEMF_ANY))
  3134.             {
  3135.                 STRPTR Result;
  3136.  
  3137.                 if(DataHold && DataSize >= Len - 1)
  3138.                 {
  3139.                     CopyMem(DataHold,Buffer,Len - 1);
  3140.  
  3141.                     BytesRead = Len - 1;
  3142.  
  3143.                     if(DataSize == Len - 1)
  3144.                     {
  3145.                         DataHold = NULL;
  3146.  
  3147.                         RestartSerial(TRUE);
  3148.                     }
  3149.                     else
  3150.                     {
  3151.                         DataHold += Len - 1;
  3152.                         DataSize -= Len - 1;
  3153.                     }
  3154.                 }
  3155.                 else
  3156.                 {
  3157.                     ULONG Signals,SignalMask = SIG_SERIAL | SIG_TIMER | SIG_BREAK;
  3158.  
  3159.                     ClearSerial();
  3160.  
  3161.                     if(DataHold)
  3162.                     {
  3163.                         CopyMem(DataHold,Buffer,DataSize);
  3164.  
  3165.                         ReadRequest -> IOSer . io_Data        = Buffer + DataSize;
  3166.                         ReadRequest -> IOSer . io_Length    = Len - 1 - DataSize;
  3167.  
  3168.                         BytesRead = DataSize;
  3169.  
  3170.                         DataHold = NULL;
  3171.                     }
  3172.                     else
  3173.                     {
  3174.                         ReadRequest -> IOSer . io_Data        = Buffer;
  3175.                         ReadRequest -> IOSer . io_Length    = Len - 1;
  3176.                     }
  3177.  
  3178.                     ReadRequest -> IOSer . io_Command = CMD_READ;
  3179.  
  3180.                     ClrSignal(SignalMask);
  3181.  
  3182.                     if(RexxTimeoutVal)
  3183.                         StartTime(RexxTimeoutVal,0);
  3184.  
  3185.                     SendIO(ReadRequest);
  3186.  
  3187.                     FOREVER
  3188.                     {
  3189.                         Signals = Wait(SignalMask);
  3190.  
  3191.                         if(Signals & SIG_SERIAL)
  3192.                         {
  3193.                             if(RexxTimeoutVal)
  3194.                                 StopTime();
  3195.  
  3196.                                 /* Did the request terminate gracefully? */
  3197.  
  3198.                             if(!WaitIO(ReadRequest))
  3199.                             {
  3200.                                 BytesIn += ReadRequest -> IOSer . io_Actual;
  3201.  
  3202.                                 BytesRead = ReadRequest -> IOSer . io_Actual;
  3203.                             }
  3204.                             else
  3205.                                 Results[0] = RC_ERROR;
  3206.  
  3207.                             break;
  3208.                         }
  3209.  
  3210.                         if(Signals & SIG_BREAK)
  3211.                         {
  3212.                             if(!CheckIO(ReadRequest))
  3213.                                 AbortIO(ReadRequest);
  3214.  
  3215.                             WaitIO(ReadRequest);
  3216.  
  3217.                             if(RexxTimeoutVal)
  3218.                                 StopTime();
  3219.  
  3220.                             Results[0] = RC_WARN;
  3221.  
  3222.                             break;
  3223.                         }
  3224.  
  3225.                         if(Signals & SIG_TIMER)
  3226.                         {
  3227.                             if(!CheckIO(ReadRequest))
  3228.                                 AbortIO(ReadRequest);
  3229.  
  3230.                             WaitIO(ReadRequest);
  3231.  
  3232.                             WaitIO(TimeRequest);
  3233.  
  3234.                             if(ReadRequest -> IOSer . io_Actual)
  3235.                             {
  3236.                                 BytesIn += ReadRequest -> IOSer . io_Actual;
  3237.  
  3238.                                 BytesRead = ReadRequest -> IOSer . io_Actual;
  3239.                             }
  3240.                             else
  3241.                             {
  3242.                                 WriteRequest -> IOSer . io_Command = SDCMD_QUERY;
  3243.  
  3244.                                 DoIO(WriteRequest);
  3245.  
  3246.                                 if(WriteRequest -> IOSer . io_Actual)
  3247.                                 {
  3248.                                         /* Don't read more than actually wanted. */
  3249.  
  3250.                                     ReadRequest -> IOSer . io_Command    = CMD_READ;
  3251.                                     ReadRequest -> IOSer . io_Data        = Buffer;
  3252.                                     ReadRequest -> IOSer . io_Length    = MIN(Len - 1,WriteRequest -> IOSer . io_Actual);
  3253.  
  3254.                                     if(!DoIO(ReadRequest))
  3255.                                     {
  3256.                                         BytesIn += ReadRequest -> IOSer . io_Actual;
  3257.  
  3258.                                         BytesRead = ReadRequest -> IOSer . io_Actual;
  3259.                                     }
  3260.                                 }
  3261.                             }
  3262.  
  3263.                             break;
  3264.                         }
  3265.                     }
  3266.                 }
  3267.  
  3268.                 if(BytesRead)
  3269.                 {
  3270.                     STRPTR MetaBuffer;
  3271.  
  3272.                     if(MetaBuffer = AllocVecPooled(Len,MEMF_ANY))
  3273.                     {
  3274.                         struct TranslationHandle    Handle;
  3275.                         LONG                Bytes;
  3276.  
  3277.                         TranslateSetup(&Handle,Buffer,BytesRead,MetaBuffer,Len - 1,ReceiveTable);
  3278.  
  3279.                         Bytes = TranslateBuffer(&Handle);
  3280.  
  3281.                         Result = CreateResultLen(MetaBuffer,Results,Bytes);
  3282.  
  3283.                         FreeVecPooled(MetaBuffer);
  3284.                     }
  3285.                     else
  3286.                     {
  3287.                         Results[0] = RC_ERROR;
  3288.                         Results[1] = ERROR_NO_FREE_STORE;
  3289.  
  3290.                         Result = NULL;
  3291.                     }
  3292.                 }
  3293.                 else
  3294.                 {
  3295.                     Results[0] = RC_WARN;
  3296.  
  3297.                     Result = NULL;
  3298.                 }
  3299.  
  3300.                 FreeVecPooled(Buffer);
  3301.  
  3302.                 RestartSerial(TRUE);
  3303.  
  3304.                 if(Args[ARG_READ_CR])
  3305.                 {
  3306.                     Forbid();
  3307.     
  3308.                     Window -> Flags &= ~WFLG_RMBTRAP;
  3309.     
  3310.                     LT_LockWindow(Window);
  3311.     
  3312.                     Permit();
  3313.                 }
  3314.  
  3315.                 ReleaseWindows();
  3316.  
  3317.                 return(Result);
  3318.             }
  3319.             else
  3320.             {
  3321.                 Results[0] = RC_ERROR;
  3322.                 Results[1] = ERROR_NO_FREE_STORE;
  3323.             }
  3324.  
  3325.             RestartSerial(TRUE);
  3326.         }
  3327.     }
  3328.  
  3329.     if(Args[ARG_READ_CR])
  3330.     {
  3331.         Forbid();
  3332.     
  3333.         Window -> Flags &= ~WFLG_RMBTRAP;
  3334.     
  3335.         LT_LockWindow(Window);
  3336.     
  3337.         Permit();
  3338.     }
  3339.  
  3340.     ReleaseWindows();
  3341.  
  3342.     return(NULL);
  3343. }
  3344.  
  3345. STRPTR
  3346. RexxReceiveFile(struct RexxPkt *Pkt)
  3347. {
  3348.     enum    {    ARG_RECEIVEFILE_MODE,ARG_RECEIVEFILE_NAME };
  3349.  
  3350.     WORD Mode = TRANSFER_BINARY;
  3351.  
  3352.     if(Args[ARG_RECEIVEFILE_MODE])
  3353.         Mode = ToMode(Args[ARG_RECEIVEFILE_MODE]);
  3354.  
  3355.     if(Mode == -1)
  3356.     {
  3357.         Results[0] = RC_ERROR;
  3358.         Results[1] = ERROR_ACTION_NOT_KNOWN;
  3359.     }
  3360.     else
  3361.     {
  3362.         BlockWindows();
  3363.  
  3364.         switch(Mode)
  3365.         {
  3366.             case TRANSFER_ASCII:
  3367.  
  3368.                 if(ChangeProtocol(Config -> TransferConfig -> ASCIIDownloadLibrary))
  3369.                 {
  3370.                     BinaryTransfer = FALSE;
  3371.  
  3372.                     StartXprReceive(TRANSFER_ASCII,NULL,FALSE);
  3373.  
  3374.                     BinaryTransfer = TRUE;
  3375.  
  3376.                     SerialCommand(Config -> CommandConfig -> DownloadMacro);
  3377.                 }
  3378.                 else
  3379.                 {
  3380.                     Results[0] = RC_ERROR;
  3381.                     Results[1] = ERROR_NO_FREE_STORE;
  3382.                 }
  3383.  
  3384.                 ResetProtocol();
  3385.  
  3386.                 break;
  3387.  
  3388.             case TRANSFER_TEXT:
  3389.  
  3390.                 if(ChangeProtocol(Config -> TransferConfig -> TextDownloadLibrary))
  3391.                 {
  3392.                     BinaryTransfer = FALSE;
  3393.  
  3394.                     StartXprReceive(TRANSFER_TEXT,NULL,FALSE);
  3395.  
  3396.                     BinaryTransfer = TRUE;
  3397.  
  3398.                     SerialCommand(Config -> CommandConfig -> DownloadMacro);
  3399.                 }
  3400.                 else
  3401.                 {
  3402.                     Results[0] = RC_ERROR;
  3403.                     Results[1] = ERROR_NO_FREE_STORE;
  3404.                 }
  3405.  
  3406.                 ResetProtocol();
  3407.  
  3408.                 break;
  3409.  
  3410.             case TRANSFER_BINARY:
  3411.  
  3412.                 if(ChangeProtocol(Config -> TransferConfig -> BinaryDownloadLibrary))
  3413.                 {
  3414.                     BinaryTransfer = TRUE;
  3415.  
  3416.                     StartXprReceive(TRANSFER_BINARY,NULL,FALSE);
  3417.  
  3418.                     SerialCommand(Config -> CommandConfig -> DownloadMacro);
  3419.                 }
  3420.                 else
  3421.                 {
  3422.                     Results[0] = RC_ERROR;
  3423.                     Results[1] = ERROR_NO_FREE_STORE;
  3424.                 }
  3425.  
  3426.                 ResetProtocol();
  3427.  
  3428.                 break;
  3429.         }
  3430.  
  3431.         if(TransferFailed)
  3432.             Results[0] = RC_ERROR;
  3433.  
  3434.         if(TransferAborted)
  3435.             Results[0] = RC_WARN;
  3436.  
  3437.         ReleaseWindows();
  3438.     }
  3439.  
  3440.     return(NULL);
  3441. }
  3442.  
  3443. STRPTR
  3444. RexxRedial(struct RexxPkt *Pkt)
  3445. {
  3446.     if(DialList)
  3447.     {
  3448.         if(DialList -> lh_Head -> ln_Succ)
  3449.             DoDial = DIAL_REDIAL;
  3450.         else
  3451.             Results[0] = RC_WARN;
  3452.     }
  3453.     else
  3454.         Results[0] = RC_WARN;
  3455.  
  3456.     return(NULL);
  3457. }
  3458.  
  3459. STRPTR
  3460. RexxRemove(struct RexxPkt *Pkt)
  3461. {
  3462.     enum    {    ARG_REMOVE_FROM,ARG_REMOVE_NAME };
  3463.  
  3464.     WORD Index;
  3465.  
  3466.     if((Index = ToList(Args[ARG_REMOVE_FROM])) == -1)
  3467.     {
  3468.         Results[0] = RC_ERROR;
  3469.         Results[1] = TERMERROR_UNKNOWN_LIST;
  3470.     }
  3471.     else
  3472.     {
  3473.         if(Args[ARG_REMOVE_NAME] && Index == GLIST_DIAL)
  3474.         {
  3475.             Results[0] = RC_ERROR;
  3476.             Results[1] = TERMERROR_DATA_TYPES_INCOMPATIBLE;
  3477.         }
  3478.         else
  3479.         {
  3480.             struct GenericList *List;
  3481.  
  3482.             List = GenericListTable[Index];
  3483.  
  3484.             if(Args[ARG_REMOVE_NAME])
  3485.             {
  3486.                 STRPTR Buffer;
  3487.  
  3488.                 if(Buffer = CreateMatchBuffer(Args[ARG_REMOVE_NAME]))
  3489.                 {
  3490.                     struct Node *Node,*NextNode;
  3491.  
  3492.                     ObtainSemaphore(&List -> ListSemaphore);
  3493.  
  3494.                     Node = (struct Node *)List -> ListHeader . mlh_Head;
  3495.  
  3496.                     while(NextNode = Node -> ln_Succ)
  3497.                     {
  3498.                         if(MatchBuffer(Buffer,Node -> ln_Name))
  3499.                         {
  3500.                             Forbid();
  3501.  
  3502.                             ReleaseSemaphore(&List -> ListSemaphore);
  3503.  
  3504.                             DeleteGenericListNode(List,Node);
  3505.  
  3506.                             ObtainSemaphore(&List -> ListSemaphore);
  3507.  
  3508.                             Permit();
  3509.                         }
  3510.  
  3511.                         Node = NextNode;
  3512.                     }
  3513.  
  3514.                     ReleaseSemaphore(&List -> ListSemaphore);
  3515.  
  3516.                     DeleteMatchBuffer(Buffer);
  3517.                 }
  3518.                 else
  3519.                 {
  3520.                     Results[0] = RC_ERROR;
  3521.                     Results[1] = ERROR_NO_FREE_STORE;
  3522.                 }
  3523.             }
  3524.             else
  3525.                 DeleteGenericListNode(List,NULL);
  3526.  
  3527.             if(!GenericListCount(List))
  3528.                 Results[0] = RC_WARN;
  3529.         }
  3530.     }
  3531.  
  3532.     return(NULL);
  3533. }
  3534.  
  3535. STRPTR
  3536. RexxRequestFile(struct RexxPkt *Pkt)
  3537. {
  3538.     enum    {    ARG_REQUESTFILE_TITLE,ARG_REQUESTFILE_PATH,ARG_REQUESTFILE_FILE,
  3539.             ARG_REQUESTFILE_PATTERN,ARG_REQUESTFILE_MULTI,ARG_REQUESTFILE_NAME };
  3540.  
  3541.     if(Args[ARG_REQUESTFILE_MULTI] && !Args[ARG_REQUESTFILE_NAME])
  3542.     {
  3543.         Results[0] = RC_ERROR;
  3544.         Results[1] = TERMERROR_RESULT_VARIABLE_REQUIRED;
  3545.     }
  3546.     else
  3547.     {
  3548.         struct FileRequester    *FileRequester;
  3549.         UBYTE             DummyBuffer[MAX_FILENAME_LENGTH],
  3550.                     *DummyChar;
  3551.         STRPTR             FileName,
  3552.                      PathName;
  3553.  
  3554.         if(Args[ARG_REQUESTFILE_PATH])
  3555.         {
  3556.             PathName = Args[ARG_REQUESTFILE_PATH];
  3557.  
  3558.             if(Args[ARG_REQUESTFILE_FILE])
  3559.                 FileName = Args[ARG_REQUESTFILE_FILE];
  3560.             else
  3561.                 FileName = "";
  3562.         }
  3563.         else
  3564.         {
  3565.             PathName = "";
  3566.  
  3567.             if(Args[ARG_REQUESTFILE_FILE])
  3568.             {
  3569.                 strcpy(DummyBuffer,Args[ARG_REQUESTFILE_FILE]);
  3570.  
  3571.                 DummyChar = PathPart(DummyBuffer);
  3572.  
  3573.                 *DummyChar = 0;
  3574.  
  3575.                 PathName = DummyBuffer;
  3576.                 FileName = FilePart(Args[ARG_REQUESTFILE_FILE]);
  3577.             }
  3578.             else
  3579.                 FileName = "";
  3580.         }
  3581.  
  3582.         BlockWindows();
  3583.  
  3584.         if(FileRequester = GetFile(Window,Args[ARG_REQUESTFILE_TITLE],PathName,FileName,DummyBuffer,Args[ARG_REQUESTFILE_PATTERN],FALSE,Args[ARG_REQUESTFILE_MULTI] != NULL,FALSE,"Ok",TRUE))
  3585.         {
  3586.             if(Args[ARG_REQUESTFILE_NAME])
  3587.             {
  3588.                 if(Args[ARG_REQUESTFILE_MULTI])
  3589.                 {
  3590.                     UBYTE         DummyBuffer[MAX_FILENAME_LENGTH];
  3591.                     struct WBArg    *ArgList = FileRequester -> rf_ArgList;
  3592.                     LONG         i,Counted = 0;
  3593.  
  3594.                     for(i = 0 ; i < FileRequester -> rf_NumArgs ; i++)
  3595.                     {
  3596.                         if(ArgList[i] . wa_Name)
  3597.                         {
  3598.                             if(ArgList[i] . wa_Lock)
  3599.                             {
  3600.                                 if(!NameFromLock(ArgList[i] . wa_Lock,DummyBuffer,MAX_FILENAME_LENGTH))
  3601.                                 {
  3602.                                     Results[0] = RC_ERROR;
  3603.                                     Results[1] = IoErr();
  3604.  
  3605.                                     break;
  3606.                                 }
  3607.                             }
  3608.                             else
  3609.                                 strcpy(DummyBuffer,FileRequester -> rf_Dir);
  3610.  
  3611.                             if(AddPart(DummyBuffer,ArgList[i] . wa_Name,MAX_FILENAME_LENGTH))
  3612.                             {
  3613.                                 if(CreateVarArgs(DummyBuffer,Pkt,"%s.%ld",Args[ARG_REQUESTFILE_NAME],i))
  3614.                                     Counted++;
  3615.                                 else
  3616.                                     break;
  3617.                             }
  3618.                             else
  3619.                             {
  3620.                                 Results[0] = RC_ERROR;
  3621.                                 Results[1] = IoErr();
  3622.  
  3623.                                 break;
  3624.                             }
  3625.                         }
  3626.                     }
  3627.  
  3628.                     if(Counted)
  3629.                     {
  3630.                         SPrintf(DummyBuffer,"%ld",Counted);
  3631.  
  3632.                         CreateVarArgs(DummyBuffer,Pkt,"%s.COUNT",Args[ARG_REQUESTFILE_NAME]);
  3633.                     }
  3634.  
  3635.                     FreeAslRequest(FileRequester);
  3636.                 }
  3637.                 else
  3638.                 {
  3639.                     FreeAslRequest(FileRequester);
  3640.  
  3641.                     ReleaseWindows();
  3642.  
  3643.                     return(CreateVar(DummyBuffer,Pkt,Args[ARG_REQUESTFILE_NAME]));
  3644.                 }
  3645.             }
  3646.             else
  3647.             {
  3648.                 FreeAslRequest(FileRequester);
  3649.  
  3650.                 ReleaseWindows();
  3651.  
  3652.                 return(CreateResult(DummyBuffer,Results));
  3653.             }
  3654.         }
  3655.         else
  3656.             Results[0] = RC_WARN;
  3657.  
  3658.         ReleaseWindows();
  3659.     }
  3660.  
  3661.     return(NULL);
  3662. }
  3663.  
  3664. STRPTR
  3665. RexxRequestNotify(struct RexxPkt *Pkt)
  3666. {
  3667.     enum    {    ARG_REQUESTNOTIFY_TITLE,ARG_REQUESTNOTIFY_PROMPT };
  3668.  
  3669.     struct EasyStruct    Easy;
  3670.     ULONG            IDCMP = NULL;
  3671.  
  3672.     Easy . es_StructSize    = sizeof(struct EasyStruct);
  3673.     Easy . es_Flags        = NULL;
  3674.     Easy . es_TextFormat    = Args[ARG_REQUESTNOTIFY_PROMPT];
  3675.     Easy . es_GadgetFormat    = LocaleString(MSG_GLOBAL_CONTINUE_TXT);
  3676.  
  3677.     if(Args[ARG_REQUESTNOTIFY_TITLE])
  3678.         Easy . es_Title    = Args[ARG_REQUESTNOTIFY_TITLE];
  3679.     else
  3680.         Easy . es_Title    = LocaleString(MSG_TERMAUX_TERM_REQUEST_TXT);
  3681.  
  3682.     BlockWindows();
  3683.  
  3684.     EasyRequestArgs(Window,&Easy,&IDCMP,NULL);
  3685.  
  3686.     ReleaseWindows();
  3687.  
  3688.     return(NULL);
  3689. }
  3690.  
  3691. STRPTR
  3692. RexxRequestNumber(struct RexxPkt *Pkt)
  3693. {
  3694.     enum    {    ARG_REQUESTNUMBER_DEFAULT,ARG_REQUESTNUMBER_PROMPT };
  3695.  
  3696.     UBYTE DummyBuffer[256];
  3697.  
  3698.     if(Args[ARG_REQUESTNUMBER_DEFAULT])
  3699.         SPrintf(DummyBuffer,"%ld",*(LONG *)Args[ARG_REQUESTNUMBER_DEFAULT]);
  3700.     else
  3701.         DummyBuffer[0] = 0;
  3702.  
  3703.     BlockWindows();
  3704.  
  3705.     if(GetString(FALSE,FALSE,255,Args[ARG_REQUESTNUMBER_PROMPT],DummyBuffer))
  3706.     {
  3707.         STRPTR Index = DummyBuffer;
  3708.  
  3709.         while(*Index == ' ' || *Index == '\t')
  3710.             Index++;
  3711.  
  3712.         if(*Index)
  3713.         {
  3714.             LONG Value;
  3715.  
  3716.             if(StrToLong(DummyBuffer,&Value) == -1)
  3717.             {
  3718.                 Results[0] = RC_ERROR;
  3719.                 Results[1] = ERROR_BAD_NUMBER;
  3720.             }
  3721.             else
  3722.             {
  3723.                 ReleaseWindows();
  3724.  
  3725.                 SPrintf(DummyBuffer,"%ld",Value);
  3726.  
  3727.                 return(CreateResult(DummyBuffer,Results));
  3728.             }
  3729.         }
  3730.         else
  3731.             Results[0] = RC_WARN;
  3732.     }
  3733.     else
  3734.         Results[0] = RC_WARN;
  3735.  
  3736.     ReleaseWindows();
  3737.  
  3738.     return(NULL);
  3739. }
  3740.  
  3741. STRPTR
  3742. RexxRequestResponse(struct RexxPkt *Pkt)
  3743. {
  3744.     enum    {    ARG_REQUESTRESPONSE_TITLE,ARG_REQUESTRESPONSE_OPTIONS,
  3745.             ARG_REQUESTRESPONSE_PROMPT };
  3746.  
  3747.     struct EasyStruct    Easy;
  3748.     ULONG            IDCMP = NULL;
  3749.     WORD            Result;
  3750.  
  3751.     Easy . es_StructSize    = sizeof(struct EasyStruct);
  3752.     Easy . es_Flags        = NULL;
  3753.     Easy . es_TextFormat    = Args[ARG_REQUESTRESPONSE_PROMPT];
  3754.  
  3755.     if(Args[ARG_REQUESTRESPONSE_OPTIONS])
  3756.         Easy . es_GadgetFormat = Args[ARG_REQUESTRESPONSE_OPTIONS];
  3757.     else
  3758.         Easy . es_GadgetFormat = LocaleString(MSG_GLOBAL_YES_NO_TXT);
  3759.  
  3760.     if(Args[ARG_REQUESTRESPONSE_TITLE])
  3761.         Easy . es_Title    = Args[ARG_REQUESTRESPONSE_TITLE];
  3762.     else
  3763.         Easy . es_Title    = LocaleString(MSG_TERMAUX_TERM_REQUEST_TXT);
  3764.  
  3765.     BlockWindows();
  3766.  
  3767.     Result = EasyRequestArgs(Window,&Easy,&IDCMP,NULL);
  3768.  
  3769.     ReleaseWindows();
  3770.  
  3771.     if(Result)
  3772.     {
  3773.         UBYTE DummyBuffer[20];
  3774.  
  3775.         SPrintf(DummyBuffer,"%ld",Result);
  3776.  
  3777.         return(CreateResult(DummyBuffer,Results));
  3778.     }
  3779.     else
  3780.     {
  3781.         Results[0] = RC_WARN;
  3782.  
  3783.         return(NULL);
  3784.     }
  3785. }
  3786.  
  3787. STRPTR
  3788. RexxRequestString(struct RexxPkt *Pkt)
  3789. {
  3790.     enum    {    ARG_REQUESTSTRING_SECRET,ARG_REQUESTSTRING_DEFAULT,ARG_REQUESTSTRING_PROMPT };
  3791.  
  3792.     UBYTE DummyBuffer[256];
  3793.  
  3794.     if(Args[ARG_REQUESTSTRING_DEFAULT])
  3795.         strcpy(DummyBuffer,Args[ARG_REQUESTSTRING_DEFAULT]);
  3796.     else
  3797.         DummyBuffer[0] = 0;
  3798.  
  3799.     BlockWindows();
  3800.  
  3801.     if(GetString(FALSE,Args[ARG_REQUESTSTRING_SECRET] != NULL,255,Args[ARG_REQUESTSTRING_PROMPT],DummyBuffer))
  3802.     {
  3803.         ReleaseWindows();
  3804.  
  3805.         return(CreateResult(DummyBuffer,Results));
  3806.     }
  3807.     else
  3808.         Results[0] = RC_WARN;
  3809.  
  3810.     ReleaseWindows();
  3811.  
  3812.     return(NULL);
  3813. }
  3814.  
  3815. STRPTR
  3816. RexxResetScreen(struct RexxPkt *Pkt)
  3817. {
  3818.     if(XEmulatorBase && Config -> TerminalConfig -> EmulationMode == EMULATION_EXTERNAL)
  3819.         XEmulatorResetConsole(XEM_IO);
  3820.     else
  3821.     {
  3822.         FreeMarker();
  3823.  
  3824.         ObtainTerminal();
  3825.  
  3826.         ClearCursor();
  3827.  
  3828.         Reset();
  3829.  
  3830.         DrawCursor();
  3831.  
  3832.         ReleaseTerminal();
  3833.     }
  3834.  
  3835.     return(NULL);
  3836. }
  3837.  
  3838. STRPTR
  3839. RexxResetStyles(struct RexxPkt *Pkt)
  3840. {
  3841.     if(XEmulatorBase && Config -> TerminalConfig -> EmulationMode == EMULATION_EXTERNAL)
  3842.         XEmulatorResetTextStyles(XEM_IO);
  3843.     else
  3844.     {
  3845.         DropMarker();
  3846.  
  3847.         ConBypass("\033[0m",-1);
  3848.  
  3849.         ObtainTerminal();
  3850.  
  3851.         ClearCursor();
  3852.  
  3853.         Config -> EmulationConfig -> FontScale = SCALE_NORMAL;
  3854.  
  3855.         FgPen = GetPenIndex(SafeTextPen);
  3856.         BgPen = 0;
  3857.  
  3858.         if(ReadAPen(RPort) != MappedPens[0][FgPen])
  3859.             SetAPen(RPort,MappedPens[0][FgPen]);
  3860.  
  3861.         if(ReadBPen(RPort) != MappedPens[0][BgPen])
  3862.             SetBPen(RPort,MappedPens[0][BgPen]);
  3863.  
  3864.         SetWrMsk(RPort,DepthMask);
  3865.  
  3866.         ConFontScaleUpdate();
  3867.  
  3868.         DrawCursor();
  3869.  
  3870.         ReleaseTerminal();
  3871.     }
  3872.  
  3873.     return(NULL);
  3874. }
  3875.  
  3876. STRPTR
  3877. RexxResetText(struct RexxPkt *Pkt)
  3878. {
  3879.     if(XEmulatorBase && Config -> TerminalConfig -> EmulationMode == EMULATION_EXTERNAL)
  3880.         XEmulatorResetCharset(XEM_IO);
  3881.     else
  3882.     {
  3883.         DropMarker();
  3884.  
  3885.         CurrentFont = TextFont;
  3886.  
  3887.         SetFont(RPort,CurrentFont);
  3888.  
  3889.         ConOutputUpdate();
  3890.     }
  3891.  
  3892.     return(NULL);
  3893. }
  3894.  
  3895. STRPTR
  3896. RexxResetTimer(struct RexxPkt *Pkt)
  3897. {
  3898.     Forbid();
  3899.  
  3900.     if(StatusProcess)
  3901.         Signal(StatusProcess,SIG_RESETTIME);
  3902.  
  3903.     Permit();
  3904.  
  3905.     return(NULL);
  3906. }
  3907.  
  3908. STRPTR
  3909. RexxSaveAs(struct RexxPkt *Pkt)
  3910. {
  3911.     enum    {    ARG_SAVEAS_NAME,ARG_SAVEAS_FROM };
  3912.  
  3913.     WORD Index = ToConfig(Args[ARG_SAVEAS_FROM]);
  3914.  
  3915.     if(Index == -1)
  3916.     {
  3917.         Results[0] = RC_ERROR;
  3918.         Results[1] = ERROR_OBJECT_NOT_FOUND;
  3919.     }
  3920.     else
  3921.     {
  3922.         UBYTE    DummyBuffer[MAX_FILENAME_LENGTH];
  3923.         STRPTR    FileName;
  3924.  
  3925.         if(Args[ARG_SAVEAS_NAME])
  3926.             FileName = Args[ARG_SAVEAS_NAME];
  3927.         else
  3928.         {
  3929.             STRPTR             Title;
  3930.             struct FileRequester    *FileRequest;
  3931.  
  3932.             FileName = NULL;
  3933.  
  3934.             switch(Index)
  3935.             {
  3936.                 case DATATYPE_TRANSLATIONS:
  3937.  
  3938.                     Title = LocaleString(MSG_TRANSLATIONPANEL_SAVE_TRANSLATION_TABLES_TXT);
  3939.                     break;
  3940.  
  3941.                 case DATATYPE_FUNCTIONKEYS:
  3942.  
  3943.                     Title = LocaleString(MSG_MACROPANEL_SAVE_MACRO_KEYS_TXT);
  3944.                     break;
  3945.  
  3946.                 case DATATYPE_CURSORKEYS:
  3947.  
  3948.                     Title = LocaleString(MSG_CURSORPANEL_SAVE_CURSOR_KEYS_TXT);
  3949.                     break;
  3950.  
  3951.                 case DATATYPE_FASTMACROS:
  3952.  
  3953.                     Title = LocaleString(MSG_FASTMACROPANEL_SAVE_FAST_MACRO_SETTINGS_TXT);
  3954.                     break;
  3955.  
  3956.                 case DATATYPE_HOTKEYS:
  3957.  
  3958.                     Title = LocaleString(MSG_HOTKEYPANEL_SAVE_HOTKEYS_TXT);
  3959.                     break;
  3960.  
  3961.                 case DATATYPE_SPEECH:
  3962.  
  3963.                     Title = LocaleString(MSG_SPEECHPANEL_SAVE_SPEECH_SETTINGS_TXT);
  3964.                     break;
  3965.  
  3966.                 case DATATYPE_SOUND:
  3967.  
  3968.                     Title = LocaleString(MSG_SOUNDPANEL_SAVE_SOUNDS_TXT);
  3969.                     break;
  3970.  
  3971.                 case DATATYPE_BUFFER:
  3972.  
  3973.                     Title = LocaleString(MSG_TERMMAIN_SAVE_BUFFER_TXT);
  3974.                     break;
  3975.  
  3976.                 case DATATYPE_CONFIGURATION:
  3977.  
  3978.                     Title = LocaleString(MSG_TERMMAIN_SAVE_PREFERENCES_AS_TXT);
  3979.                     break;
  3980.  
  3981.                 case DATATYPE_PHONEBOOK:
  3982.  
  3983.                     Title = LocaleString(MSG_PHONEPANEL_SAVE_PHONEBOOK_TXT);
  3984.                     break;
  3985.  
  3986.                 case DATATYPE_SCREENTEXT:
  3987.  
  3988.                     Title = LocaleString(MSG_TERMMAIN_SAVE_SCREEN_ASCII_TXT);
  3989.                     break;
  3990.  
  3991.                 case DATATYPE_SCREENIMAGE:
  3992.  
  3993.                     Title = LocaleString(MSG_TERMMAIN_SAVE_SCREEN_IFF_TXT);
  3994.                     break;
  3995.             }
  3996.  
  3997.             BlockWindows();
  3998.  
  3999.             if(FileRequest = GetFile(Window,Title,"","",DummyBuffer,NULL,TRUE,FALSE,FALSE,NULL,TRUE))
  4000.             {
  4001.                 FileName = DummyBuffer;
  4002.  
  4003.                 FreeAslRequest(FileRequest);
  4004.             }
  4005.  
  4006.             ReleaseWindows();
  4007.         }
  4008.  
  4009.         if(FileName)
  4010.         {
  4011.             switch(Index)
  4012.             {
  4013.                 case DATATYPE_TRANSLATIONS:
  4014.                 {
  4015.                     if(SendTable && ReceiveTable)
  4016.                     {
  4017.                         if(!SaveTranslationTables(FileName,SendTable,ReceiveTable))
  4018.                         {
  4019.                             Results[0] = RC_ERROR;
  4020.                             Results[1] = IoErr();
  4021.                         }
  4022.                         else
  4023.                         {
  4024.                             strcpy(LastTranslation,FileName);
  4025.  
  4026.                             TranslationChanged = FALSE;
  4027.                         }
  4028.                     }
  4029.                     else
  4030.                         Results[0] = RC_WARN;
  4031.                 }
  4032.  
  4033.                 break;
  4034.  
  4035.                 case DATATYPE_FUNCTIONKEYS:
  4036.                 {
  4037.                     if(!WriteIFFData(FileName,MacroKeys,sizeof(struct MacroKeys),ID_KEYS))
  4038.                     {
  4039.                         Results[0] = RC_ERROR;
  4040.                         Results[1] = IoErr();
  4041.                     }
  4042.                     else
  4043.                     {
  4044.                         strcpy(LastMacros,FileName);
  4045.  
  4046.                         MacroChanged = FALSE;
  4047.                     }
  4048.                 }
  4049.  
  4050.                 break;
  4051.  
  4052.                 case DATATYPE_CURSORKEYS:
  4053.                 {
  4054.                     if(!WriteIFFData(FileName,CursorKeys,sizeof(struct CursorKeys),ID_KEYS))
  4055.                     {
  4056.                         Results[0] = RC_ERROR;
  4057.                         Results[1] = IoErr();
  4058.                     }
  4059.                     else
  4060.                     {
  4061.                         strcpy(LastCursorKeys,FileName);
  4062.  
  4063.                         CursorKeysChanged = FALSE;
  4064.                     }
  4065.                 }
  4066.  
  4067.                 break;
  4068.  
  4069.                 case DATATYPE_FASTMACROS:
  4070.                 {
  4071.                     if(!SaveFastMacros(FileName))
  4072.                     {
  4073.                         Results[0] = RC_ERROR;
  4074.                         Results[1] = IoErr();
  4075.                     }
  4076.                     else
  4077.                     {
  4078.                         strcpy(LastFastMacros,FileName);
  4079.  
  4080.                         FastMacrosChanged = FALSE;
  4081.                     }
  4082.                 }
  4083.  
  4084.                 break;
  4085.  
  4086.                 case DATATYPE_HOTKEYS:
  4087.                 {
  4088.                     if(!WriteIFFData(FileName,&Hotkeys,sizeof(struct Hotkeys),ID_HOTK))
  4089.                     {
  4090.                         Results[0] = RC_ERROR;
  4091.                         Results[1] = IoErr();
  4092.                     }
  4093.                     else
  4094.                     {
  4095.                         strcpy(LastKeys,FileName);
  4096.  
  4097.                         HotkeysChanged = FALSE;
  4098.                     }
  4099.                 }
  4100.  
  4101.                 break;
  4102.  
  4103.                 case DATATYPE_SPEECH:
  4104.                 {
  4105.                     if(!WriteIFFData(FileName,&SpeechConfig,sizeof(struct SpeechConfig),ID_SPEK))
  4106.                     {
  4107.                         Results[0] = RC_ERROR;
  4108.                         Results[1] = IoErr();
  4109.                     }
  4110.                     else
  4111.                     {
  4112.                         strcpy(LastSpeech,FileName);
  4113.  
  4114.                         SpeechChanged = FALSE;
  4115.                     }
  4116.                 }
  4117.  
  4118.                 break;
  4119.  
  4120.                 case DATATYPE_SOUND:
  4121.                 {
  4122.                     if(!WriteIFFData(FileName,&SoundConfig,sizeof(struct SoundConfig),ID_SOUN))
  4123.                     {
  4124.                         Results[0] = RC_ERROR;
  4125.                         Results[1] = IoErr();
  4126.                     }
  4127.                     else
  4128.                     {
  4129.                         strcpy(LastSound,FileName);
  4130.  
  4131.                         SoundChanged = FALSE;
  4132.                     }
  4133.                 }
  4134.  
  4135.                 break;
  4136.  
  4137.                 case DATATYPE_BUFFER:
  4138.                 {
  4139.                     if(BufferLines && Lines)
  4140.                     {
  4141.                         BPTR SomeFile;
  4142.  
  4143.                         if(GetFileSize(FileName))
  4144.                         {
  4145.                             if(SomeFile = Open(FileName,MODE_READWRITE))
  4146.                             {
  4147.                                 if(Seek(SomeFile,0,OFFSET_END) == -1)
  4148.                                 {
  4149.                                     Close(SomeFile);
  4150.  
  4151.                                     SomeFile = NULL;
  4152.  
  4153.                                     SetIoErr(ERROR_SEEK_ERROR);
  4154.                                 }
  4155.                             }
  4156.                         }
  4157.                         else
  4158.                             SomeFile = Open(FileName,MODE_NEWFILE);
  4159.  
  4160.                         if(SomeFile)
  4161.                         {
  4162.                             LONG i,Len;
  4163.  
  4164.                                 /* Obtain the semaphore required
  4165.                                  * to gain access to the line buffer
  4166.                                  */
  4167.  
  4168.                             ObtainSemaphore(BufferSemaphore);
  4169.  
  4170.                             for(i = 0 ; i < Lines ; i++)
  4171.                             {
  4172.                                 Len = BufferLines[i][-1];
  4173.  
  4174.                                 if(Len)
  4175.                                 {
  4176.                                     if(FWrite(SomeFile,BufferLines[i],Len,1) != 1)
  4177.                                     {
  4178.                                         Results[0] = RC_ERROR;
  4179.                                         Results[1] = IoErr();
  4180.  
  4181.                                         break;
  4182.                                     }
  4183.                                 }
  4184.  
  4185.                                 if(FPrintf(SomeFile,"\n") < 1)
  4186.                                 {
  4187.                                     Results[0] = RC_ERROR;
  4188.                                     Results[1] = IoErr();
  4189.  
  4190.                                     break;
  4191.                                 }
  4192.                             }
  4193.  
  4194.                             ReleaseSemaphore(BufferSemaphore);
  4195.  
  4196.                             Close(SomeFile);
  4197.  
  4198.                             AddProtection(FileName,FIBF_EXECUTE);
  4199.  
  4200.                             if(Config -> MiscConfig -> CreateIcons)
  4201.                                 AddIcon(FileName,FILETYPE_TEXT,TRUE);
  4202.  
  4203.                             BufferChanged = FALSE;
  4204.                         }
  4205.                         else
  4206.                         {
  4207.                             Results[0] = RC_ERROR;
  4208.                             Results[1] = IoErr();
  4209.                         }
  4210.                     }
  4211.                     else
  4212.                     {
  4213.                         Results[0] = RC_ERROR;
  4214.                         Results[1] = TERMERROR_NO_DATA_TO_PROCESS;
  4215.                     }
  4216.                 }
  4217.  
  4218.                 break;
  4219.  
  4220.                 case DATATYPE_CONFIGURATION:
  4221.                 {
  4222.                     if(!WriteConfig(FileName,Config))
  4223.                     {
  4224.                         Results[0] = RC_ERROR;
  4225.                         Results[1] = IoErr();
  4226.                     }
  4227.                     else
  4228.                     {
  4229.                         strcpy(LastConfig,FileName);
  4230.  
  4231.                         ConfigChanged = FALSE;
  4232.                     }
  4233.                 }
  4234.  
  4235.                 break;
  4236.  
  4237.                 case DATATYPE_PHONEBOOK:
  4238.                 {
  4239.                     if(!SavePhonebook(FileName))
  4240.                     {
  4241.                         Results[0] = RC_ERROR;
  4242.                         Results[1] = IoErr();
  4243.                     }
  4244.                     else
  4245.                     {
  4246.                         strcpy(LastPhone,FileName);
  4247.  
  4248.                         PhonebookChanged = FALSE;
  4249.                     }
  4250.                 }
  4251.  
  4252.                 break;
  4253.  
  4254.                 case DATATYPE_SCREENTEXT:
  4255.                 {
  4256.                     if(RasterEnabled)
  4257.                     {
  4258.                         BPTR SomeFile;
  4259.  
  4260.                         if(GetFileSize(FileName))
  4261.                         {
  4262.                             if(SomeFile = Open(FileName,MODE_READWRITE))
  4263.                             {
  4264.                                 if(Seek(SomeFile,0,OFFSET_END) == -1)
  4265.                                 {
  4266.                                     Close(SomeFile);
  4267.  
  4268.                                     SomeFile = NULL;
  4269.  
  4270.                                     SetIoErr(ERROR_SEEK_ERROR);
  4271.                                 }
  4272.                             }
  4273.                         }
  4274.                         else
  4275.                             SomeFile = Open(FileName,MODE_NEWFILE);
  4276.  
  4277.                         if(SomeFile)
  4278.                         {
  4279.                             LONG     i,j;
  4280.                             UBYTE    *Buffer;
  4281.  
  4282.                             for(i = 0 ; i < RasterHeight ; i++)
  4283.                             {
  4284.                                 Buffer = &Raster[i * RasterWidth];
  4285.  
  4286.                                 j = LastColumn;
  4287.  
  4288.                                 while(j >= 0 && Buffer[j] == ' ')
  4289.                                     j--;
  4290.  
  4291.                                 if(j >= 0)
  4292.                                 {
  4293.                                     if(!FWrite(SomeFile,Buffer,j + 1,1))
  4294.                                     {
  4295.                                         Results[0] = RC_ERROR;
  4296.                                         Results[1] = IoErr();
  4297.  
  4298.                                         break;
  4299.                                     }
  4300.                                 }
  4301.  
  4302.                                 if(!FWrite(SomeFile,"\n",1,1))
  4303.                                 {
  4304.                                     Results[0] = RC_ERROR;
  4305.                                     Results[1] = IoErr();
  4306.  
  4307.                                     break;
  4308.                                 }
  4309.                             }
  4310.  
  4311.                             Close(SomeFile);
  4312.  
  4313.                             AddProtection(FileName,FIBF_EXECUTE);
  4314.  
  4315.                             if(Config -> MiscConfig -> CreateIcons)
  4316.                                 AddIcon(FileName,FILETYPE_TEXT,TRUE);
  4317.                         }
  4318.                         else
  4319.                         {
  4320.                             Results[0] = RC_ERROR;
  4321.                             Results[1] = IoErr();
  4322.                         }
  4323.                     }
  4324.                     else
  4325.                     {
  4326.                         Results[0] = RC_ERROR;
  4327.                         Results[1] = TERMERROR_NO_DATA_TO_PROCESS;
  4328.                     }
  4329.                 }
  4330.  
  4331.                 break;
  4332.  
  4333.                 case DATATYPE_SCREENIMAGE:
  4334.                 {
  4335.                     if(!SaveWindow(FileName,Window))
  4336.                     {
  4337.                         Results[0] = RC_ERROR;
  4338.                         Results[1] = IoErr();
  4339.                     }
  4340.                 }
  4341.  
  4342.                 break;
  4343.             }
  4344.         }
  4345.         else
  4346.             Results[0] = RC_WARN;
  4347.     }
  4348.  
  4349.     return(NULL);
  4350. }
  4351.  
  4352. STRPTR
  4353. RexxSave(struct RexxPkt *Pkt)
  4354. {
  4355.     enum    {    ARG_SAVE_FROM };
  4356.  
  4357.     Args[1] = Args[ARG_SAVE_FROM];
  4358.     Args[0] = NULL;
  4359.  
  4360.     return(RexxSaveAs(Pkt));
  4361. }
  4362.  
  4363. STRPTR
  4364. RexxSelect(struct RexxPkt *Pkt)
  4365. {
  4366.     enum    {    ARG_SELECT_NAME,ARG_SELECT_FROM,ARG_SELECT_NEXT,ARG_SELECT_PREVIOUS,
  4367.             ARG_SELECT_TOP,ARG_SELECT_BOTTOM };
  4368.  
  4369.     WORD Index;
  4370.  
  4371.     if((Index = ToList(Args[ARG_SELECT_FROM])) == -1)
  4372.     {
  4373.         Results[0] = RC_ERROR;
  4374.         Results[1] = TERMERROR_UNKNOWN_LIST;
  4375.     }
  4376.     else
  4377.     {
  4378.         if(Args[ARG_SELECT_NAME] && Index == GLIST_DIAL)
  4379.         {
  4380.             Results[0] = RC_ERROR;
  4381.             Results[1] = TERMERROR_DATA_TYPES_INCOMPATIBLE;
  4382.         }
  4383.         else
  4384.         {
  4385.             struct GenericList *List;
  4386.  
  4387.             List = GenericListTable[Index];
  4388.  
  4389.             if(Args[ARG_SELECT_NAME])
  4390.             {
  4391.                 STRPTR Buffer;
  4392.  
  4393.                 if(Buffer = CreateMatchBuffer(Args[ARG_SELECT_NAME]))
  4394.                 {
  4395.                     struct Node *Node,*NextNode;
  4396.  
  4397.                     ObtainSemaphore(&List -> ListSemaphore);
  4398.  
  4399.                     Node = (struct Node *)List -> ListHeader . mlh_Head;
  4400.  
  4401.                     while(NextNode = Node -> ln_Succ)
  4402.                     {
  4403.                         if(MatchBuffer(Buffer,Node -> ln_Name))
  4404.                         {
  4405.                             List -> ListNode = Node;
  4406.  
  4407.                             Node = NULL;
  4408.  
  4409.                             break;
  4410.                         }
  4411.  
  4412.                         Node = NextNode;
  4413.                     }
  4414.  
  4415.                     if(Node)
  4416.                         Results[0] = RC_WARN;
  4417.  
  4418.                     ReleaseSemaphore(&List -> ListSemaphore);
  4419.  
  4420.                     DeleteMatchBuffer(Buffer);
  4421.                 }
  4422.                 else
  4423.                 {
  4424.                     Results[0] = RC_ERROR;
  4425.                     Results[1] = ERROR_NO_FREE_STORE;
  4426.                 }
  4427.             }
  4428.             else
  4429.             {
  4430.                 if(Args[ARG_SELECT_NEXT])
  4431.                 {
  4432.                     if(!NextGenericListNode(List))
  4433.                     {
  4434.                         Results[0] = RC_WARN;
  4435.  
  4436.                         return(NULL);
  4437.                     }
  4438.                 }
  4439.  
  4440.                 if(Args[ARG_SELECT_PREVIOUS])
  4441.                 {
  4442.                     if(!PrevGenericListNode(List))
  4443.                     {
  4444.                         Results[0] = RC_WARN;
  4445.  
  4446.                         return(NULL);
  4447.                     }
  4448.                 }
  4449.  
  4450.                 if(Args[ARG_SELECT_TOP])
  4451.                 {
  4452.                     if(!FirstGenericListNode(List))
  4453.                     {
  4454.                         Results[0] = RC_WARN;
  4455.  
  4456.                         return(NULL);
  4457.                     }
  4458.                 }
  4459.  
  4460.                 if(Args[ARG_SELECT_BOTTOM])
  4461.                 {
  4462.                     if(!LastGenericListNode(List))
  4463.                     {
  4464.                         Results[0] = RC_WARN;
  4465.  
  4466.                         return(NULL);
  4467.                     }
  4468.                 }
  4469.             }
  4470.  
  4471.             ObtainSemaphore(&List -> ListSemaphore);
  4472.  
  4473.             if(List -> ListNode)
  4474.             {
  4475.                 if(Index != GLIST_DIAL)
  4476.                 {
  4477.                     struct Node    *Node = (struct Node *)List -> ListNode;
  4478.                     STRPTR         Result;
  4479.  
  4480.                     Result = CreateResult(Node -> ln_Name,Results);
  4481.  
  4482.                     ReleaseSemaphore(&List -> ListSemaphore);
  4483.  
  4484.                     return(Result);
  4485.                 }
  4486.             }
  4487.             else
  4488.                 Results[0] = RC_WARN;
  4489.  
  4490.             ReleaseSemaphore(&List -> ListSemaphore);
  4491.         }
  4492.     }
  4493.  
  4494.     return(NULL);
  4495. }
  4496.  
  4497. STRPTR
  4498. RexxSend(struct RexxPkt *Pkt)
  4499. {
  4500.     enum    {    ARG_SEND_NOECHO,ARG_SEND_LOCAL,ARG_SEND_BYTE,ARG_SEND_TEXT };
  4501.  
  4502.     if(Args[ARG_SEND_LOCAL])
  4503.     {
  4504.         if(!Args[ARG_SEND_NOECHO])
  4505.         {
  4506.             if(Marking)
  4507.                 DropMarker();
  4508.  
  4509.             if(Args[ARG_SEND_TEXT])
  4510.                 ConsoleCommand(Args[ARG_SEND_TEXT]);
  4511.             else
  4512.             {
  4513.                 UBYTE Byte = *(LONG *)Args[ARG_SEND_BYTE];
  4514.  
  4515.                 ConProcess(&Byte,1);
  4516.             }
  4517.         }
  4518.     }
  4519.     else
  4520.     {
  4521.         if(Args[ARG_SEND_NOECHO])
  4522.             Quiet = TRUE;
  4523.  
  4524.         if(Args[ARG_SEND_TEXT])
  4525.             SerialCommand(Args[ARG_SEND_TEXT]);
  4526.         else
  4527.         {
  4528.             UBYTE Byte = *(LONG *)Args[ARG_SEND_BYTE];
  4529.  
  4530.             SerWrite(&Byte,1);
  4531.         }
  4532.  
  4533.         Quiet = FALSE;
  4534.     }
  4535.  
  4536.     return(NULL);
  4537. }
  4538.  
  4539. STRPTR
  4540. RexxSendBreak(struct RexxPkt *Pkt)
  4541. {
  4542.     if(WriteRequest)
  4543.         SendBreak();
  4544.     else
  4545.         Results[0] = RC_WARN;
  4546.  
  4547.     return(NULL);
  4548. }
  4549.  
  4550. STRPTR
  4551. RexxSendFile(struct RexxPkt *Pkt)
  4552. {
  4553.     enum    {    ARG_SENDFILE_MODE,ARG_SENDFILE_NAMES };
  4554.  
  4555.     WORD Mode = TRANSFER_BINARY;
  4556.  
  4557.     if(Args[ARG_SENDFILE_MODE])
  4558.         Mode = ToMode(Args[ARG_SENDFILE_MODE]);
  4559.  
  4560.     if(Mode == -1)
  4561.     {
  4562.         Results[0] = RC_ERROR;
  4563.         Results[1] = ERROR_ACTION_NOT_KNOWN;
  4564.     }
  4565.     else
  4566.     {
  4567.         struct FileTransferInfo    *Info;
  4568.         LONG             FilesFound = 0;
  4569.  
  4570.         if(Info = AllocFileTransferInfo())
  4571.         {
  4572.             struct GenericList *List = GenericListTable[GLIST_UPLOAD];
  4573.  
  4574.             if(Args[ARG_SENDFILE_NAMES])
  4575.             {
  4576.                 struct FileInfoBlock *FileInfo;
  4577.  
  4578.                 if(FileInfo = (struct FileInfoBlock *)AllocDosObject(DOS_FIB,TAG_DONE))
  4579.                 {
  4580.                     STRPTR    *Names = (STRPTR *)Args[ARG_SENDFILE_NAMES];
  4581.                     BPTR     FileLock,NewDir,OldDir;
  4582.  
  4583.                     NewDir = NULL;
  4584.  
  4585.                     switch(Mode)
  4586.                     {
  4587.                         case TRANSFER_BINARY:
  4588.  
  4589.                             if(Config -> PathConfig -> BinaryUploadPath[0])
  4590.                                 NewDir = Lock(Config -> PathConfig -> BinaryUploadPath,ACCESS_READ);
  4591.  
  4592.                             break;
  4593.  
  4594.                         case TRANSFER_TEXT:
  4595.  
  4596.                             if(Config -> PathConfig -> TextUploadPath[0])
  4597.                                 NewDir = Lock(Config -> PathConfig -> TextUploadPath,ACCESS_READ);
  4598.  
  4599.                             break;
  4600.  
  4601.                         case TRANSFER_ASCII:
  4602.  
  4603.                             if(Config -> PathConfig -> ASCIIUploadPath[0])
  4604.                                 NewDir = Lock(Config -> PathConfig -> ASCIIUploadPath,ACCESS_READ);
  4605.  
  4606.                             break;
  4607.                     }
  4608.  
  4609.                     if(NewDir)
  4610.                         OldDir = CurrentDir(NewDir);
  4611.                     else
  4612.                         OldDir = NULL;
  4613.  
  4614.                     while(*Names && Results[0] == RC_OK)
  4615.                     {
  4616.                         if(FileLock = Lock(*Names,ACCESS_READ))
  4617.                         {
  4618.                             if(Examine(FileLock,FileInfo))
  4619.                             {
  4620.                                 if(FileInfo -> fib_DirEntryType < 0)
  4621.                                 {
  4622.                                     if(NameFromLock(FileLock,SharedBuffer,512))
  4623.                                     {
  4624.                                         if(AddFileTransferNode(Info,SharedBuffer,FileInfo -> fib_Size))
  4625.                                             FilesFound++;
  4626.                                         else
  4627.                                         {
  4628.                                             Results[0] = RC_ERROR;
  4629.                                             Results[1] = ERROR_NO_FREE_STORE;
  4630.                                         }
  4631.                                     }
  4632.                                     else
  4633.                                     {
  4634.                                         Results[0] = RC_ERROR;
  4635.                                         Results[1] = IoErr();
  4636.                                     }
  4637.                                 }
  4638.                                 else
  4639.                                 {
  4640.                                     Results[0] = RC_ERROR;
  4641.                                     Results[1] = ERROR_OBJECT_WRONG_TYPE;
  4642.                                 }
  4643.                             }
  4644.                             else
  4645.                             {
  4646.                                 Results[0] = RC_ERROR;
  4647.                                 Results[1] = IoErr();
  4648.                             }
  4649.  
  4650.                             UnLock(FileLock);
  4651.                         }
  4652.                         else
  4653.                         {
  4654.                             Results[0] = RC_ERROR;
  4655.                             Results[1] = IoErr();
  4656.                         }
  4657.  
  4658.                         Names++;
  4659.                     }
  4660.  
  4661.                     if(OldDir)
  4662.                         CurrentDir(OldDir);
  4663.  
  4664.                     if(NewDir)
  4665.                         UnLock(NewDir);
  4666.  
  4667.                     FreeDosObject(DOS_FIB,FileInfo);
  4668.                 }
  4669.                 else
  4670.                 {
  4671.                     Results[0] = RC_ERROR;
  4672.                     Results[1] = ERROR_NO_FREE_STORE;
  4673.                 }
  4674.             }
  4675.  
  4676.             ObtainSemaphore(&List -> ListSemaphore);
  4677.  
  4678.             if(List -> ListHeader . mlh_Head -> mln_Succ)
  4679.             {
  4680.                 struct Node        *Node = (struct Node *)List -> ListHeader . mlh_Head;
  4681.                 struct FileInfoBlock    *FileInfo;
  4682.                 BPTR             NewDir,OldDir;
  4683.  
  4684.                 NewDir = NULL;
  4685.  
  4686.                 switch(Mode)
  4687.                 {
  4688.                     case TRANSFER_BINARY:
  4689.  
  4690.                         if(Config -> PathConfig -> BinaryUploadPath[0])
  4691.                             NewDir = Lock(Config -> PathConfig -> BinaryUploadPath,ACCESS_READ);
  4692.  
  4693.                         break;
  4694.  
  4695.                     case TRANSFER_TEXT:
  4696.  
  4697.                         if(Config -> PathConfig -> TextUploadPath[0])
  4698.                             NewDir = Lock(Config -> PathConfig -> TextUploadPath,ACCESS_READ);
  4699.  
  4700.                         break;
  4701.  
  4702.                     case TRANSFER_ASCII:
  4703.  
  4704.                         if(Config -> PathConfig -> ASCIIUploadPath[0])
  4705.                             NewDir = Lock(Config -> PathConfig -> ASCIIUploadPath,ACCESS_READ);
  4706.  
  4707.                         break;
  4708.                 }
  4709.  
  4710.                 if(NewDir)
  4711.                     OldDir = CurrentDir(NewDir);
  4712.                 else
  4713.                     OldDir = NULL;
  4714.  
  4715.                 if(FileInfo = (struct FileInfoBlock *)AllocDosObject(DOS_FIB,TAG_DONE))
  4716.                 {
  4717.                     BPTR FileLock;
  4718.  
  4719.                     while(Node -> ln_Succ && Results[0] == RC_OK)
  4720.                     {
  4721.                         if(FileLock = Lock(Node -> ln_Name,ACCESS_READ))
  4722.                         {
  4723.                             if(Examine(FileLock,FileInfo))
  4724.                             {
  4725.                                 if(FileInfo -> fib_DirEntryType < 0)
  4726.                                 {
  4727.                                     if(NameFromLock(FileLock,SharedBuffer,512))
  4728.                                     {
  4729.                                         if(AddFileTransferNode(Info,SharedBuffer,FileInfo -> fib_Size))
  4730.                                             FilesFound++;
  4731.                                         else
  4732.                                         {
  4733.                                             Results[0] = RC_ERROR;
  4734.                                             Results[1] = ERROR_NO_FREE_STORE;
  4735.                                         }
  4736.                                     }
  4737.                                     else
  4738.                                     {
  4739.                                         Results[0] = RC_ERROR;
  4740.                                         Results[1] = IoErr();
  4741.                                     }
  4742.                                 }
  4743.                                 else
  4744.                                 {
  4745.                                     Results[0] = RC_ERROR;
  4746.                                     Results[1] = ERROR_OBJECT_WRONG_TYPE;
  4747.                                 }
  4748.                             }
  4749.                             else
  4750.                             {
  4751.                                 Results[0] = RC_ERROR;
  4752.                                 Results[1] = IoErr();
  4753.                             }
  4754.  
  4755.                             UnLock(FileLock);
  4756.                         }
  4757.                         else
  4758.                         {
  4759.                             Results[0] = RC_ERROR;
  4760.                             Results[1] = IoErr();
  4761.                         }
  4762.  
  4763.                         Node = Node -> ln_Succ;
  4764.                     }
  4765.  
  4766.                     if(OldDir)
  4767.                         CurrentDir(OldDir);
  4768.  
  4769.                     if(NewDir)
  4770.                         UnLock(NewDir);
  4771.  
  4772.                     FreeDosObject(DOS_FIB,FileInfo);
  4773.                 }
  4774.                 else
  4775.                 {
  4776.                     Results[0] = RC_ERROR;
  4777.                     Results[1] = ERROR_NO_FREE_STORE;
  4778.                 }
  4779.             }
  4780.  
  4781.             ReleaseSemaphore(&List -> ListSemaphore);
  4782.  
  4783.             if(Results[0] == RC_OK)
  4784.             {
  4785.                 BlockWindows();
  4786.  
  4787.                 if(FilesFound)
  4788.                 {
  4789.                     SortFileTransferInfo(Info);
  4790.  
  4791.                     FileTransferInfo = Info;
  4792.                 }
  4793.  
  4794.                 switch(Mode)
  4795.                 {
  4796.                     case TRANSFER_ASCII:
  4797.  
  4798.                         if(ChangeProtocol(Config -> TransferConfig -> ASCIIUploadLibrary))
  4799.                         {
  4800.                             BinaryTransfer = FALSE;
  4801.  
  4802.                             if(FilesFound)
  4803.                                 StartXprSendFromList(TRANSFER_ASCII,FALSE);
  4804.                             else
  4805.                                 StartXprSend(TRANSFER_ASCII,FALSE);
  4806.  
  4807.                             BinaryTransfer = TRUE;
  4808.  
  4809.                             SerialCommand(Config -> CommandConfig -> UploadMacro);
  4810.                         }
  4811.                         else
  4812.                         {
  4813.                             Results[0] = RC_ERROR;
  4814.                             Results[1] = ERROR_NO_FREE_STORE;
  4815.                         }
  4816.  
  4817.                         ResetProtocol();
  4818.  
  4819.                         break;
  4820.  
  4821.                     case TRANSFER_TEXT:
  4822.  
  4823.                         if(ChangeProtocol(Config -> TransferConfig -> TextUploadLibrary))
  4824.                         {
  4825.                             BinaryTransfer = FALSE;
  4826.  
  4827.                             if(FilesFound)
  4828.                                 StartXprSendFromList(TRANSFER_TEXT,FALSE);
  4829.                             else
  4830.                                 StartXprSend(TRANSFER_TEXT,FALSE);
  4831.  
  4832.                             BinaryTransfer = TRUE;
  4833.  
  4834.                             SerialCommand(Config -> CommandConfig -> UploadMacro);
  4835.                         }
  4836.                         else
  4837.                         {
  4838.                             Results[0] = RC_ERROR;
  4839.                             Results[1] = ERROR_NO_FREE_STORE;
  4840.                         }
  4841.  
  4842.                         ResetProtocol();
  4843.  
  4844.                         break;
  4845.  
  4846.                     case TRANSFER_BINARY:
  4847.  
  4848.                         if(ChangeProtocol(Config -> TransferConfig -> BinaryUploadLibrary))
  4849.                         {
  4850.                             BinaryTransfer = TRUE;
  4851.  
  4852.                             if(FilesFound)
  4853.                                 StartXprSendFromList(TRANSFER_BINARY,FALSE);
  4854.                             else
  4855.                                 StartXprSend(TRANSFER_BINARY,FALSE);
  4856.  
  4857.                             SerialCommand(Config -> CommandConfig -> UploadMacro);
  4858.                         }
  4859.                         else
  4860.                         {
  4861.                             Results[0] = RC_ERROR;
  4862.                             Results[1] = ERROR_NO_FREE_STORE;
  4863.                         }
  4864.  
  4865.                         ResetProtocol();
  4866.  
  4867.                         break;
  4868.                 }
  4869.  
  4870.                 if(TransferFailed)
  4871.                     Results[0] = RC_ERROR;
  4872.  
  4873.                 if(TransferAborted)
  4874.                     Results[0] = RC_WARN;
  4875.  
  4876.                 ReleaseWindows();
  4877.             }
  4878.             else
  4879.                 FreeFileTransferInfo(Info);
  4880.         }
  4881.         else
  4882.         {
  4883.             Results[0] = RC_ERROR;
  4884.             Results[1] = ERROR_NO_FREE_STORE;
  4885.         }
  4886.     }
  4887.  
  4888.     return(NULL);
  4889. }
  4890.  
  4891. STRPTR
  4892. RexxSpeak(struct RexxPkt *Pkt)
  4893. {
  4894.     enum    {    ARG_SPEAK_TEXT };
  4895.  
  4896.     if(SpeechConfig . Enabled && English)
  4897.         Say(Args[ARG_SPEAK_TEXT]);
  4898.     else
  4899.         Results[0] = RC_WARN;
  4900.  
  4901.     return(NULL);
  4902. }
  4903.  
  4904. STRPTR
  4905. RexxStopBits(struct RexxPkt *Pkt)
  4906. {
  4907.     enum    {    ARG_STOPBITS_0,ARG_STOPBITS_1 };
  4908.  
  4909.     BYTE Bits;
  4910.  
  4911.     if(Args[ARG_STOPBITS_0])
  4912.         Bits = 0;
  4913.  
  4914.     if(Args[ARG_STOPBITS_1])
  4915.         Bits = 1;
  4916.  
  4917.     if(Config -> SerialConfig -> StopBits != Bits)
  4918.     {
  4919.         Config -> SerialConfig -> StopBits = Bits;
  4920.  
  4921.         UpdateRequired = TRUE;
  4922.  
  4923.         ConfigChanged = TRUE;
  4924.     }
  4925.  
  4926.     return(NULL);
  4927. }
  4928.  
  4929. STRPTR
  4930. RexxTextBuffer(struct RexxPkt *Pkt)
  4931. {
  4932.     enum    {    ARG_TEXTBUFFER_LOCK,ARG_TEXTBUFFER_UNLOCK };
  4933.  
  4934.     Forbid();
  4935.  
  4936.     if(Args[ARG_TEXTBUFFER_LOCK])
  4937.         BufferFrozen = TRUE;
  4938.  
  4939.     if(Args[ARG_TEXTBUFFER_UNLOCK])
  4940.         BufferFrozen = FALSE;
  4941.  
  4942.     CheckItem(MEN_FREEZE_BUFFER,BufferFrozen);
  4943.  
  4944.     ConOutputUpdate();
  4945.  
  4946.     Permit();
  4947.  
  4948.     return(NULL);
  4949. }
  4950.  
  4951. STRPTR
  4952. RexxTimeout(struct RexxPkt *Pkt)
  4953. {
  4954.     enum    {    ARG_TIMEOUT_SECONDS,ARG_TIMEOUT_OFF };
  4955.  
  4956.     if(Args[ARG_TIMEOUT_OFF])
  4957.         RexxTimeoutVal = 0;
  4958.     else
  4959.         RexxTimeoutVal = *(LONG *)Args[ARG_TIMEOUT_SECONDS];
  4960.  
  4961.     return(NULL);
  4962.  
  4963. }
  4964.  
  4965. STRPTR
  4966. RexxTrap(struct RexxPkt *Pkt)
  4967. {
  4968.     enum    {    ARG_TRAP_ON,ARG_TRAP_OFF };
  4969.  
  4970.     BOOLEAN Enabled;
  4971.  
  4972.     Forbid();
  4973.  
  4974.     if(Args[ARG_TRAP_ON])
  4975.         Enabled = TRUE;
  4976.  
  4977.     if(Args[ARG_TRAP_OFF])
  4978.         Enabled = FALSE;
  4979.  
  4980.     CheckItem(MEN_DISABLE_TRAPS,Enabled ^ TRUE);
  4981.  
  4982.     Permit();
  4983.  
  4984.     ObtainSemaphore(&GenericListTable[GLIST_TRAP] -> ListSemaphore);
  4985.  
  4986.     if(GenericListTable[GLIST_TRAP] -> ListHeader . mlh_Head -> mln_Succ && Enabled)
  4987.         WatchTraps = TRUE;
  4988.     else
  4989.         WatchTraps = FALSE;
  4990.  
  4991.     ReleaseSemaphore(&GenericListTable[GLIST_TRAP] -> ListSemaphore);
  4992.  
  4993.     return(NULL);
  4994. }
  4995.  
  4996. STATIC STRPTR         RexxWaitResult;
  4997. STATIC struct WaitNode    *RexxWaitNode;
  4998.  
  4999. STATIC BOOLEAN
  5000. RexxWaitBypass(STRPTR Buffer,LONG Size)
  5001. {
  5002.     LONG Position;
  5003.  
  5004.     RexxWaitResult = ScanNodeFilter(Buffer,Size,RexxWaitNode,&Position);
  5005.  
  5006.     SerWriteVerbatim(Buffer,Size,FALSE);
  5007.  
  5008.     return(FALSE);
  5009. }
  5010.  
  5011. STRPTR
  5012. RexxWait(struct RexxPkt *Pkt)
  5013. {
  5014.     enum    {    ARG_WAIT_NOECHO,ARG_WAIT_TEXT };
  5015.  
  5016.     ULONG         Signals;
  5017.     STRPTR         Result = NULL;
  5018.     BYTE         Echo;
  5019.     struct WaitNode    *WaitNode,
  5020.              Node;
  5021.     UBYTE         DummyBuffer[256];
  5022.     LONG         Position;
  5023.     struct List     DummyList;
  5024.  
  5025.     if(!ReadRequest || !WriteRequest)
  5026.     {
  5027.         Results[0] = RC_WARN;
  5028.  
  5029.         return(NULL);
  5030.     }
  5031.  
  5032.     if(Args[ARG_WAIT_NOECHO])
  5033.         Echo = FALSE;
  5034.     else
  5035.         Echo = TRUE;
  5036.  
  5037.     if(Args[ARG_WAIT_TEXT])
  5038.     {
  5039.         WORD i,Len;
  5040.  
  5041.         NewList(&DummyList);
  5042.  
  5043.         memcpy(DummyBuffer,Args[ARG_WAIT_TEXT],255);
  5044.  
  5045.         DummyBuffer[255] = 0;
  5046.  
  5047.         for(i = 0 ; i < strlen(DummyBuffer) ; i++)
  5048.             DummyBuffer[i] = ToUpper(DummyBuffer[i]);
  5049.  
  5050.         Len = TranslateString(DummyBuffer,DummyBuffer);
  5051.  
  5052.         DummyBuffer[Len] = 0;
  5053.  
  5054.         memset(&Node,0,sizeof(struct WaitNode));
  5055.  
  5056.         Node . Node . ln_Name    = DummyBuffer;
  5057.         Node . Count        = 0;
  5058.  
  5059.         WaitNode = &Node;
  5060.  
  5061.         AddTail(&DummyList,(struct Node *)WaitNode);
  5062.     }
  5063.     else
  5064.     {
  5065.         if(!GenericListCount(GenericListTable[GLIST_WAIT]))
  5066.         {
  5067.             Results[0] = RC_ERROR;
  5068.             Results[1] = TERMERROR_LIST_IS_ALREADY_EMPTY;
  5069.  
  5070.             return(NULL);
  5071.         }
  5072.         else
  5073.         {
  5074.             WaitNode = (struct WaitNode *)GenericListTable[GLIST_WAIT] -> ListHeader . mlh_Head;
  5075.  
  5076.             while(WaitNode -> Node . ln_Succ)
  5077.             {
  5078.                 WaitNode -> Count = 0;
  5079.  
  5080.                 WaitNode = (struct WaitNode *)WaitNode -> Node . ln_Succ;
  5081.             }
  5082.  
  5083.             WaitNode = NULL;
  5084.         }
  5085.     }
  5086.  
  5087.     if(RexxTimeoutVal)
  5088.         StartTime(RexxTimeoutVal,0);
  5089.  
  5090.     WaitCount = 0;
  5091.  
  5092.     BlockWindows();
  5093.  
  5094.     Forbid();
  5095.  
  5096.     LT_UnlockWindow(Window);
  5097.  
  5098.     Window -> Flags |= WFLG_RMBTRAP;
  5099.  
  5100.     Permit();
  5101.  
  5102.     if(Marking)
  5103.         DropMarker();
  5104.  
  5105.     NormalCursor();
  5106.  
  5107.     if(DataHold)
  5108.     {
  5109.         if(Echo)
  5110.         {
  5111.             ConProcess(DataHold,DataSize);
  5112.  
  5113.             Status = STATUS_READY;
  5114.         }
  5115.  
  5116.         if(Result = ScanNodeFilter(DataHold,DataSize,WaitNode,&Position))
  5117.         {
  5118.             if(Position < DataSize)
  5119.             {
  5120.                 DataHold += Position;
  5121.                 DataSize -= Position;
  5122.             }
  5123.             else
  5124.             {
  5125.                 DataHold = NULL;
  5126.  
  5127.                 RestartSerial(TRUE);
  5128.             }
  5129.         }
  5130.         else
  5131.         {
  5132.             DataHold = NULL;
  5133.  
  5134.             RestartSerial(TRUE);
  5135.         }
  5136.     }
  5137.  
  5138.     if(!Result)
  5139.     {
  5140.         if(CheckIO(ReadRequest))
  5141.             Signals = SIG_SERIAL;
  5142.         else
  5143.             Signals = NULL;
  5144.  
  5145.         do
  5146.         {
  5147.             if(Signals & SIG_WINDOW)
  5148.             {
  5149.                 if(!Result)
  5150.                 {
  5151.                     SerWriteBypass = RexxWaitBypass;
  5152.     
  5153.                     RexxWaitResult    = Result;
  5154.                     RexxWaitNode    = WaitNode;
  5155.     
  5156.                     while(HandleWindow());
  5157.     
  5158.                     Result = RexxWaitResult;
  5159.     
  5160.                     SerWriteBypass = NULL;
  5161.                 }
  5162.             }
  5163.  
  5164.             if(Signals & SIG_SERIAL)
  5165.             {
  5166.                 BOOLEAN Restart = TRUE;
  5167.  
  5168.                 if(!WaitIO(ReadRequest))
  5169.                 {
  5170.                     LONG Length;
  5171.  
  5172.                     BytesIn++;
  5173.  
  5174.                     if(Echo)
  5175.                     {
  5176.                         ConProcess(ReadBuffer,1);
  5177.  
  5178.                         Status = STATUS_READY;
  5179.                     }
  5180.  
  5181.                     if(!Result)
  5182.                         Result = ScanNodeFilter(ReadBuffer,1,WaitNode,&Position);
  5183.  
  5184.                     if(!Result)
  5185.                     {
  5186.                             /* Check how many bytes are still in
  5187.                              * the serial buffer.
  5188.                              */
  5189.  
  5190.                         WriteRequest -> IOSer . io_Command = SDCMD_QUERY;
  5191.  
  5192.                         DoIO(WriteRequest);
  5193.  
  5194.                         if(Length = WriteRequest -> IOSer . io_Actual)
  5195.                         {
  5196.                             if(Length > Config -> SerialConfig -> SerialBufferSize)
  5197.                                 Length = Config -> SerialConfig -> SerialBufferSize;
  5198.  
  5199.                             if(Length > Config -> SerialConfig -> Quantum)
  5200.                                 Length = Config -> SerialConfig -> Quantum;
  5201.  
  5202.                             ReadRequest -> IOSer . io_Command    = CMD_READ;
  5203.                             ReadRequest -> IOSer . io_Data        = ReadBuffer;
  5204.                             ReadRequest -> IOSer . io_Length    = Length;
  5205.  
  5206.                             if(!DoIO(ReadRequest))
  5207.                             {
  5208.                                 BytesIn += Length;
  5209.  
  5210.                                     /* Send the data to the console. */
  5211.  
  5212.                                 if(Echo)
  5213.                                 {
  5214.                                     ConProcess(ReadBuffer,Length);
  5215.  
  5216.                                     Status = STATUS_READY;
  5217.                                 }
  5218.  
  5219.                                 if(Result = ScanNodeFilter(ReadBuffer,Length,WaitNode,&Position))
  5220.                                 {
  5221.                                     if(Position < Length)
  5222.                                     {
  5223.                                         DataHold = (UBYTE *)ReadBuffer    + Position;
  5224.                                         DataSize = Length        - Position;
  5225.  
  5226.                                         Restart = FALSE;
  5227.                                     }
  5228.                                     else
  5229.                                         DataHold = NULL;
  5230.                                 }
  5231.                             }
  5232.                         }
  5233.                     }
  5234.                 }
  5235.  
  5236.                 if(Restart)
  5237.                     RestartSerial(TRUE);
  5238.             }
  5239.  
  5240.             if(Signals & (SIG_BREAK | SIG_TIMER))
  5241.             {
  5242.                 if(!Result)
  5243.                     Results[0] = RC_WARN;
  5244.  
  5245.                 break;
  5246.             }
  5247.  
  5248.             if(!Result)
  5249.                 Signals = Wait(SIG_SERIAL | SIG_TIMER | SIG_BREAK | SIG_WINDOW);
  5250.         }
  5251.         while(!Result);
  5252.     }
  5253.  
  5254.     Forbid();
  5255.     
  5256.     Window -> Flags &= ~WFLG_RMBTRAP;
  5257.     
  5258.     LT_LockWindow(Window);
  5259.     
  5260.     Permit();
  5261.  
  5262.     ReleaseWindows();
  5263.  
  5264.     if(RexxTimeoutVal)
  5265.         StopTime();
  5266.  
  5267.     if(Result)
  5268.         return(CreateResult(Result,Results));
  5269.     else
  5270.         return(NULL);
  5271. }
  5272.  
  5273. STRPTR
  5274. RexxWindow(struct RexxPkt *Pkt)
  5275. {
  5276.     enum    {    ARG_WINDOW_NAMES,ARG_WINDOW_OPEN,ARG_WINDOW_CLOSE,ARG_WINDOW_ACTIVATE,
  5277.             ARG_WINDOW_MIN,ARG_WINDOW_MAX,ARG_WINDOW_FRONT,ARG_WINDOW_BACK,
  5278.             ARG_WINDOW_TOP,ARG_WINDOW_BOTTOM,ARG_WINDOW_UP,ARG_WINDOW_DOWN };
  5279.  
  5280.     STRPTR    *Names = (STRPTR *)Args[ARG_WINDOW_NAMES];
  5281.     WORD     Index;
  5282.  
  5283.     while(*Names)
  5284.     {
  5285.         if((Index = ToWindow(*Names++)) != -1)
  5286.         {
  5287.             if(Args[ARG_WINDOW_OPEN])
  5288.             {
  5289.                 Forbid();
  5290.  
  5291.                 switch(Index)
  5292.                 {
  5293.                     case WINDOWID_BUFFER:
  5294.  
  5295.                         ObtainSemaphore(&BufferTaskSemaphore);
  5296.  
  5297.                         if(!BufferTask)
  5298.                         {
  5299.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5300.  
  5301.                             LaunchBuffer();
  5302.                         }
  5303.                         else
  5304.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5305.  
  5306.                         break;
  5307.  
  5308.                     case WINDOWID_UPLOAD_QUEUE:
  5309.  
  5310.                         CreateQueueProcess();
  5311.  
  5312.                         break;
  5313.  
  5314.                     case WINDOWID_REVIEW:
  5315.  
  5316.                         if(!ReviewWindow)
  5317.                             CreateReview();
  5318.  
  5319.                         break;
  5320.  
  5321.                     case WINDOWID_PACKET:
  5322.  
  5323.                         if(!PacketWindow)
  5324.                             CreatePacketWindow();
  5325.  
  5326.                         break;
  5327.  
  5328.                     case WINDOWID_FASTMACROS:
  5329.  
  5330.                         if(!FastWindow)
  5331.                             OpenFastWindow();
  5332.  
  5333.                         break;
  5334.  
  5335.                     case WINDOWID_STATUS:
  5336.  
  5337.                         if(!InfoWindow)
  5338.                             OpenInfoWindow();
  5339.  
  5340.                         break;
  5341.  
  5342.                     case WINDOWID_MAIN:
  5343.  
  5344.                         if(!IconTerminated)
  5345.                             IconTerminated = TRUE;
  5346.  
  5347.                         break;
  5348.                 }
  5349.  
  5350.                 Permit();
  5351.             }
  5352.  
  5353.             if(Args[ARG_WINDOW_CLOSE])
  5354.             {
  5355.                 Forbid();
  5356.  
  5357.                 switch(Index)
  5358.                 {
  5359.                     case WINDOWID_UPLOAD_QUEUE:
  5360.  
  5361.                         CloseQueueWindow();
  5362.                         break;
  5363.  
  5364.                     case WINDOWID_BUFFER:
  5365.  
  5366.                         ObtainSemaphore(&BufferTaskSemaphore);
  5367.  
  5368.                         if(BufferTask)
  5369.                         {
  5370.                             Signal(BufferTask,SIG_KILL);
  5371.  
  5372.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5373.  
  5374.                             ClrSignal(SIG_HANDSHAKE);
  5375.  
  5376.                             Wait(SIG_HANDSHAKE);
  5377.                         }
  5378.                         else
  5379.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5380.  
  5381.                         break;
  5382.  
  5383.                     case WINDOWID_REVIEW:
  5384.  
  5385.                         if(ReviewWindow)
  5386.                             DeleteReview();
  5387.  
  5388.                         break;
  5389.  
  5390.                     case WINDOWID_PACKET:
  5391.  
  5392.                         if(PacketWindow)
  5393.                             DeletePacketWindow(FALSE);
  5394.  
  5395.                         break;
  5396.  
  5397.                     case WINDOWID_FASTMACROS:
  5398.  
  5399.                         if(FastWindow)
  5400.                             CloseFastWindow();
  5401.  
  5402.                         break;
  5403.  
  5404.                     case WINDOWID_STATUS:
  5405.  
  5406.                         if(InfoWindow)
  5407.                             CloseInfoWindow();
  5408.  
  5409.                         break;
  5410.  
  5411.                     case WINDOWID_MAIN:
  5412.  
  5413.                         if(Window)
  5414.                             DoIconify = TRUE;
  5415.  
  5416.                         break;
  5417.                 }
  5418.  
  5419.                 Permit();
  5420.             }
  5421.  
  5422.             if(Args[ARG_WINDOW_ACTIVATE])
  5423.             {
  5424.                 Forbid();
  5425.  
  5426.                 switch(Index)
  5427.                 {
  5428.                     case WINDOWID_UPLOAD_QUEUE:
  5429.  
  5430.                         CreateQueueProcess();
  5431.  
  5432.                         break;
  5433.  
  5434.                     case WINDOWID_BUFFER:
  5435.  
  5436.                         ObtainSemaphore(&BufferTaskSemaphore);
  5437.  
  5438.                         if(BufferTask)
  5439.                         {
  5440.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5441.  
  5442.                             LaunchBuffer();
  5443.                         }
  5444.                         else
  5445.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5446.  
  5447.                         break;
  5448.  
  5449.                     case WINDOWID_REVIEW:
  5450.  
  5451.                         if(ReviewWindow)
  5452.                             BumpWindow(ReviewWindow);
  5453.  
  5454.                         break;
  5455.  
  5456.                     case WINDOWID_PACKET:
  5457.  
  5458.                         if(PacketWindow)
  5459.                             BumpWindow(PacketWindow);
  5460.  
  5461.                         break;
  5462.  
  5463.                     case WINDOWID_FASTMACROS:
  5464.  
  5465.                         if(FastWindow)
  5466.                             BumpWindow(FastWindow);
  5467.  
  5468.                         break;
  5469.  
  5470.                     case WINDOWID_STATUS:
  5471.  
  5472.                         if(InfoWindow)
  5473.                             BumpWindow(InfoWindow);
  5474.  
  5475.                         break;
  5476.  
  5477.                     case WINDOWID_MAIN:
  5478.  
  5479.                         if(Window)
  5480.                             BumpWindow(Window);
  5481.  
  5482.                         break;
  5483.                 }
  5484.  
  5485.                 Permit();
  5486.             }
  5487.  
  5488.             if(Args[ARG_WINDOW_MIN])
  5489.             {
  5490.                 struct Window *SomeWindow = NULL;
  5491.  
  5492.                 Forbid();
  5493.  
  5494.                 switch(Index)
  5495.                 {
  5496.                     case WINDOWID_REVIEW:
  5497.  
  5498.                         SomeWindow = ReviewWindow;
  5499.                         break;
  5500.  
  5501.                     case WINDOWID_PACKET:
  5502.  
  5503.                         SomeWindow = PacketWindow;
  5504.                         break;
  5505.  
  5506.                     case WINDOWID_FASTMACROS:
  5507.  
  5508.                         SomeWindow = FastWindow;
  5509.                         break;
  5510.  
  5511.                     case WINDOWID_STATUS:
  5512.  
  5513.                         SomeWindow = InfoWindow;
  5514.                         break;
  5515.                 }
  5516.  
  5517.                 if(SomeWindow)
  5518.                     ChangeWindowBox(SomeWindow,SomeWindow -> LeftEdge,SomeWindow -> TopEdge,SomeWindow -> MinWidth,SomeWindow -> MinHeight);
  5519.  
  5520.                 Permit();
  5521.             }
  5522.  
  5523.             if(Args[ARG_WINDOW_MAX])
  5524.             {
  5525.                 struct Window *SomeWindow = NULL;
  5526.  
  5527.                 Forbid();
  5528.  
  5529.                 switch(Index)
  5530.                 {
  5531.                     case WINDOWID_REVIEW:
  5532.  
  5533.                         SomeWindow = ReviewWindow;
  5534.                         break;
  5535.  
  5536.                     case WINDOWID_PACKET:
  5537.  
  5538.                         SomeWindow = PacketWindow;
  5539.                         break;
  5540.  
  5541.                     case WINDOWID_FASTMACROS:
  5542.  
  5543.                         SomeWindow = FastWindow;
  5544.                         break;
  5545.  
  5546.                     case WINDOWID_STATUS:
  5547.  
  5548.                         SomeWindow = InfoWindow;
  5549.                         break;
  5550.                 }
  5551.  
  5552.                 if(SomeWindow)
  5553.                     ChangeWindowBox(SomeWindow,0,0,SomeWindow -> MaxWidth,SomeWindow -> MaxHeight);
  5554.  
  5555.                 Permit();
  5556.             }
  5557.  
  5558.             if(Args[ARG_WINDOW_FRONT])
  5559.             {
  5560.                 Forbid();
  5561.  
  5562.                 switch(Index)
  5563.                 {
  5564.                     case WINDOWID_UPLOAD_QUEUE:
  5565.  
  5566.                         CreateQueueProcess();
  5567.  
  5568.                         break;
  5569.  
  5570.                     case WINDOWID_BUFFER:
  5571.  
  5572.                         ObtainSemaphore(&BufferTaskSemaphore);
  5573.  
  5574.                         if(BufferTask)
  5575.                         {
  5576.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5577.  
  5578.                             LaunchBuffer();
  5579.                         }
  5580.                         else
  5581.                             ReleaseSemaphore(&BufferTaskSemaphore);
  5582.  
  5583.                         break;
  5584.  
  5585.                     case WINDOWID_REVIEW:
  5586.  
  5587.                         if(ReviewWindow)
  5588.                             WindowToFront(ReviewWindow);
  5589.  
  5590.                         break;
  5591.  
  5592.                     case WINDOWID_PACKET:
  5593.  
  5594.                         if(PacketWindow)
  5595.                             WindowToFront(PacketWindow);
  5596.  
  5597.                         break;
  5598.  
  5599.                     case WINDOWID_FASTMACROS:
  5600.  
  5601.                         if(FastWindow)
  5602.                             WindowToFront(FastWindow);
  5603.  
  5604.                         break;
  5605.  
  5606.                     case WINDOWID_STATUS:
  5607.  
  5608.                         if(InfoWindow)
  5609.                             WindowToFront(InfoWindow);
  5610.  
  5611.                         break;
  5612.  
  5613.                     case WINDOWID_MAIN:
  5614.  
  5615.                         if(Window)
  5616.                             WindowToFront(Window);
  5617.  
  5618.                         break;
  5619.                 }
  5620.  
  5621.                 Permit();
  5622.             }
  5623.  
  5624.             if(Args[ARG_WINDOW_BACK])
  5625.             {
  5626.                 Forbid();
  5627.  
  5628.                 switch(Index)
  5629.                 {
  5630.                     case WINDOWID_REVIEW:
  5631.  
  5632.                         if(ReviewWindow)
  5633.                             WindowToBack(ReviewWindow);
  5634.  
  5635.                         break;
  5636.  
  5637.                     case WINDOWID_PACKET:
  5638.  
  5639.                         if(PacketWindow)
  5640.                             WindowToBack(PacketWindow);
  5641.  
  5642.                         break;
  5643.  
  5644.                     case WINDOWID_FASTMACROS:
  5645.  
  5646.                         if(FastWindow)
  5647.                             WindowToBack(FastWindow);
  5648.  
  5649.                         break;
  5650.  
  5651.                     case WINDOWID_STATUS:
  5652.  
  5653.                         if(InfoWindow)
  5654.                             WindowToBack(InfoWindow);
  5655.  
  5656.                         break;
  5657.  
  5658.                     case WINDOWID_MAIN:
  5659.  
  5660.                         if(Window)
  5661.                             WindowToBack(Window);
  5662.  
  5663.                         break;
  5664.                 }
  5665.  
  5666.                 Permit();
  5667.             }
  5668.  
  5669.             Forbid();
  5670.  
  5671.             if(Index == WINDOW_REVIEW && ReviewWindow)
  5672.             {
  5673.                 if(Args[ARG_WINDOW_TOP])
  5674.                     MoveReview(REVIEW_MOVE_TOP);
  5675.  
  5676.                 if(Args[ARG_WINDOW_BOTTOM])
  5677.                     MoveReview(REVIEW_MOVE_BOTTOM);
  5678.  
  5679.                 if(Args[ARG_WINDOW_UP])
  5680.                     MoveReview(REVIEW_MOVE_UP);
  5681.  
  5682.                 if(Args[ARG_WINDOW_DOWN])
  5683.                     MoveReview(REVIEW_MOVE_DOWN);
  5684.             }
  5685.  
  5686.             Permit();
  5687.         }
  5688.     }
  5689.  
  5690.     return(NULL);
  5691. }
  5692.  
  5693. STRPTR
  5694. RexxRX(struct RexxPkt *Pkt)
  5695. {
  5696.     enum    {    ARG_RX_CONSOLE,ARG_RX_ASYNC,ARG_RX_COMMAND };
  5697.  
  5698.     struct MsgPort    *RexxPort;
  5699.     BYTE         Eaten = FALSE;
  5700.  
  5701.     if(RexxPort = FindPort(RXSDIR))
  5702.     {
  5703.         struct MsgPort __aligned     SinglePort;
  5704.         struct RexxMsg            *HostMessage;
  5705.  
  5706.         InitSinglePort(&SinglePort);
  5707.  
  5708.         if(HostMessage = CreateRexxMsg(&SinglePort,"term",RexxPortName))
  5709.         {
  5710.             if(HostMessage -> rm_Args[0] = CreateArgstring(Args[ARG_RX_COMMAND],strlen(Args[ARG_RX_COMMAND])))
  5711.             {
  5712.                 HostMessage -> rm_Action = RXCOMM;
  5713.  
  5714.                 if(!GoodStream(NULL))
  5715.                     HostMessage -> rm_Action |= RXFF_NOIO;
  5716.  
  5717.                 if(Args[ARG_RX_ASYNC])
  5718.                 {
  5719.                     RexxPktCleanup(Pkt,NULL);
  5720.  
  5721.                     Eaten = TRUE;
  5722.                 }
  5723.  
  5724.                 Forbid();
  5725.  
  5726.                 PutMsg(RexxPort,HostMessage);
  5727.  
  5728.                 ClrSignal(SIGF_SINGLE);
  5729.  
  5730.                 WaitPort(&SinglePort);
  5731.  
  5732.                 Permit();
  5733.  
  5734.                 GetMsg(&SinglePort);
  5735.  
  5736.                 if(!Eaten)
  5737.                 {
  5738.                     Results[0] = HostMessage -> rm_Result1;
  5739.                     Results[1] = HostMessage -> rm_Result2;
  5740.                 }
  5741.             }
  5742.             else
  5743.             {
  5744.                 Results[0] = RC_ERROR;
  5745.                 Results[1] = ERR10_003;
  5746.             }
  5747.  
  5748.             DeleteRexxMsg(HostMessage);
  5749.         }
  5750.         else
  5751.         {
  5752.             Results[0] = RC_ERROR;
  5753.             Results[1] = ERR10_003;
  5754.         }
  5755.     }
  5756.     else
  5757.     {
  5758.         Results[0] = RC_ERROR;
  5759.         Results[1] = ERR10_013;
  5760.     }
  5761.  
  5762.     if(!Eaten)
  5763.         RexxPktCleanup(Pkt,NULL);
  5764.  
  5765.     return(NULL);
  5766. }
  5767.  
  5768. STRPTR
  5769. RexxExecTool(struct RexxPkt *Pkt)
  5770. {
  5771.     enum    {    ARG_EXECTOOL_CONSOLE,ARG_EXECTOOL_ASYNC,ARG_EXECTOOL_PORT,ARG_EXECTOOL_COMMAND };
  5772.  
  5773.     LONG     Error;
  5774.     UBYTE     CommandName[256],
  5775.          CommandArgs[256],
  5776.         *Index = Args[ARG_EXECTOOL_COMMAND];
  5777.     WORD     i;
  5778.     BYTE     Eaten = FALSE;
  5779.  
  5780.     while(*Index == ' ' || *Index == '\t')
  5781.         Index++;
  5782.  
  5783.     for(i = 0 ; Index[i] != ' ' && Index[i] != '\t' ; i++)
  5784.         CommandName[i] = Index[i];
  5785.  
  5786.     CommandName[i] = 0;
  5787.  
  5788.     Index += i;
  5789.  
  5790.     while(*Index == ' ' || *Index == '\t')
  5791.         Index++;
  5792.  
  5793.     if(Args[ARG_EXECTOOL_PORT])
  5794.         SPrintf(CommandArgs,"%s %s\n",Index,RexxPortName);
  5795.     else
  5796.         SPrintf(CommandArgs,"%s\n",Index);
  5797.  
  5798.     if(Args[ARG_EXECTOOL_ASYNC])
  5799.     {
  5800.         RexxPktCleanup(Pkt,NULL);
  5801.  
  5802.         Eaten = TRUE;
  5803.     }
  5804.  
  5805.     Error = SystemTags(CommandName,
  5806.         NP_Arguments,    CommandArgs,
  5807.         SYS_UserShell,    TRUE,
  5808.     TAG_DONE);
  5809.  
  5810.     if(!Eaten)
  5811.     {
  5812.         if(Error)
  5813.         {
  5814.             Results[0] = RC_ERROR;
  5815.             Results[1] = Error;
  5816.         }
  5817.  
  5818.         RexxPktCleanup(Pkt,NULL);
  5819.     }
  5820.  
  5821.     return(NULL);
  5822. }
  5823.